//           recibo.C
//  Mon May 16 14:31:55 2011
//  Copyright  2011  Alcione Ferreira
//  <alcione.sombra@gmail.com>

#include <recibo.h>

/**
 *
 */
COLUNASR::COLUNASR()
	{
	int i;/**<Variável local para contagem dos campos*/
	this->n_campos = 7;
	add(this->descricao);
	add(this->cod_func);
	add(this->tipo);
	add(this->n_recibo);
	add(this->data);
	add(this->cod_cli);
	add(this->cod_servico);
	for(i=0; i< this->n_campos; i++)
		{
		add(this->campo[i]);
		}
	for (i=0; i < 5; i++)
		{
		add(this->Dados[i]);
		}
	add(this->campo_num);
	add(this->campo_int);
	add(this->campo_int2);
	}

/**
 *
 */
COLUNASR::~COLUNASR()
	{
			
	}

/**
 *\param funcionario recebe o código do funcionário que está logado
 */
RECIBO::RECIBO(BANCOPG *conecao, int funcionario, bool caixa)
	{
	string aux;
	this->s_issqn = false;
	ato_gratuito = false;
	this->vlr_bsissqn = 0.0;
	this->caixa = caixa;
	this->conexao = conecao;
	this->cod_fun = funcionario;
	this->cod_fun_sel = funcionario;
	this->n_login.clear();
	this->n_func.clear();
	this->n_acesso = -1;
	this->carregar_usuario();
	this->status_p = 0;
	this->janela = 1;
	this->pos_entry = 0;
	this->entry_ativa = 0;
	aux.clear();
	aux.append(IMG_PATH);
	aux+="recibo.ico";
	this->ponteiro_icon=Gdk::Pixbuf::create_from_file (aux);

	this->carregar_janela();
	}

/**
 *
 */
RECIBO::~RECIBO()
	{
	this->sair(1);
	}

/**
 * \param tela refere-se a janela que foi aberta
 */
void RECIBO::sair(int tela)
	{
	switch(tela)
		{
		case 1:
			{
			this->Principal.hide();
			break;
			}
		case 2:
			{
			this->Recibo->hide();
			this->carregar_primeiro();
			break;
			}
		case 3:
			{
			this->Fun_Dig->hide();
			break;
			}
		case 4:
			{
			this->SelRec->hide();
			break;
			}
		}
	}

/**
 * \param local usado para indicar qual Entry será checada.
 */
void RECIBO::digito(int local)
	{
	string digito;
	int len;
	digito.clear();
	switch(local)
		{
		case 1:
			{
			digito = this->Rec_CliCod->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len]))
				{
				digito[len] = '\0';
				}
			this->Rec_CliCod->set_text(digito);
			break;
			}
		case 2:
			{
			digito = this->Rec_Doc->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len]))
				{
				digito[len] = '\0';
				}
			this->Rec_Doc->set_text(digito);
			break;
			}
		case 3:
			{
			digito = this->Rec_SerCod->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len]))
				{
				digito[len] = '\0';
				}
			this->Rec_SerCod->set_text(digito);
			break;
			}
		case 4:
			{
			digito = this->Rec_SerQtd->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len]))
				{
				digito[len] = '\0';
				}
			this->Rec_SerQtd->set_text(digito);
			break;
			}
		case 5:
			{
			digito = this->Rec_SerDesc->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len])&&(digito[len] != ','))
				{
				digito[len] = '\0';
				}
			this->Rec_SerDesc->set_text(digito);
			break;
			}
		case 6:
			{
			digito = this->Rec_Total->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len])&&(digito[len] != ','))
				{
				digito[len] = '\0';
				}
			this->Rec_Total->set_text(digito);
			break;
			}
		case 7:
			{
			digito = this->SelNumero->get_text();
			len = digito.length()-1;
			if (!isdigit(digito[len]))
				{
				digito[len] = '\0';
				}
			this->SelNumero->set_text(digito);
			break;
			}
		}
	}

/**
 *
 */
void RECIBO::digitos (Gtk::Entry *e)
	{
	string digito;
	int len;
		
	digito = e->get_text();
	len = digito.length()-1;
	if (!isdigit(digito[len]))
		{
		digito[len] = '\0';
		}
	e->set_text(digito);
	}

/**
 * \param local usado para indicar qual Entry será checada.
 */
void RECIBO::letra(int local)
	{
	string letras;
	int len;

	letras.clear();
	switch(local)
		{
		case 1:
			{
			letras = this->Rec_Cliente->get_text();
			this->Rec_Cliente->set_text(Glib::ustring(ParaMaiusculos(letras)));
			break;
			}
		case 2:
			{
			letras = this->Rec_End->get_text();
			this->Rec_End->set_text(Glib::ustring(ParaMaiusculos(letras)));
			break;
			}
		case 3:
			{
			letras = this->Rec_Servico->get_text();
			this->Rec_Servico->set_text(Glib::ustring(ParaMaiusculos(letras)));
			break;
			}
		case 4:
			{
			letras = this->RecSer_Hist->get_text();
			this->RecSer_Hist->set_text(Glib::ustring(ParaMaiusculos(letras)));
			break;
			}
		}
	}

/**
 * \param ativo usado para indicar qual Entry será focada.
 */
void RECIBO::tabular(int ativo)
	{
	string AUX;
	int it;
	switch(ativo)
		{
		case 1:
			{
			this->Recibo->set_focus(*this->Rec_Doc);
			break;
			}
		case 2:
			{
			AUX.clear();
			AUX = this->Rec_SerQtd->get_text();
			if ((AUX.length() > 0)&&(!(AUX.compare("0")==0)))
				{
				this->Recibo->set_focus(*this->Rec_SerVUni);
				}
			else
				{
				Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Quantidade"), false, Gtk::MESSAGE_WARNING);
				dialog.set_secondary_text(Glib::ustring("A quantidade deve ser informada!\nE ser maior que 0(zero)!"));
				dialog.run();
				this->Recibo->set_focus(*this->Rec_SerQtd);
				}
			break;
			}
		case 3:
			{
			AUX.clear();
			AUX = this->Rec_Total->get_text();
			if (AUX.length() > 0)
				{
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,"");
					}
				this->Rec_Total->set_text(AUX);
				}
			this->Recibo->set_focus(*this->Rec_Total);
			break;
			}
		case 4:
			{
			this->Recibo->set_focus(*this->Rec_GERAR);
			break;
			}
		case 5:
			{
			this->SelRec->set_focus(*this->SelNumero);
			this->preparar_dados(7,1);
			break;
			}
		case 6:
			{
			this->SelRec->set_focus(*this->SelOK);
			break;
			}
		}
	}

/**
 *
 */
void RECIBO::tabular2()
	{
	this->Fun_Dig->set_focus(*this->E_CodFun);
	}

/**
 *
 */
void RECIBO::tabulacao(Gtk::Window *j, Gtk::Widget *w)
	{
	j->set_focus(*w);
	}

/**
 * \param funcionario código do funcionário logado/selecionado.
 */
void RECIBO::ultima_data(int funcionario)
	{
	char *sql, *codigo;
	int total;
	string SQL;
	vector<string> linha;

	codigo = new char[32];
	sprintf(codigo,"%d",funcionario);
	SQL.clear();
	SQL = "select data from caixa.lancamentos where cod_fun=";
	SQL.append(codigo);
	SQL += " order by data desc limit 1 offset 0";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		this->data_sel.clear();
		if (this->conexao->registros != 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			this->data_sel = linha.at(0);
			}
		else
			{
			this->data_sel = hoje();
			}
		}
	delete codigo;
	}

void RECIBO::carregar_usuario()
	{
	string SQL;
	char *sql, *aux;
	vector<string> linha;

	SQL.clear();
	SQL = "select nome, u_login, acesso from cadastro.funcionario where cod_fun=";
	aux = new char[10];
	itoa(this->cod_fun, aux, 10);
	SQL.append(aux);
	delete aux;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	if (this->conexao->query_result == 2)
		{
		conexao->resultado();
		linha = conexao->resultados.at(0);
		this->n_func = linha.at(0);
		this->n_login = linha.at(1);
		this->n_acesso = atoi(linha.at(2).c_str ());
		}
	else if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	delete sql;
	}

/**
 * Este método é controla por uma flag representada pela variável janela, que dependendo do valor
 * carrega a referida Janela do sistema.
 */
void RECIBO::carregar_janela()
	{
	//Gtk::Button *TESTE;
	string aux;
	char *aux_dt;
	switch(this->janela)
		{
		case 1:
			{
			if (this->status_p == 0)
				{
				this->status_p = 1;
				this->Principal.set_title(Glib::ustring("Recibo"));
				this->Principal.set_size_request(800,600);
				this->Principal.set_icon(this->ponteiro_icon);
				this->Principal.set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
				this->Principal.set_position(Gtk::WIN_POS_CENTER);
				this->Principal.signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),1));
				this->Principal.signal_show().connect(sigc::mem_fun(*this,&RECIBO::carregar_primeiro));
				this->B_Principal.set_homogeneous(false);
				this->B_Principal.set_spacing(false);
				this->L_Janela = new Gtk::Label(Glib::ustring("Funcionário: "));
				this->HP_Funcionario.pack_start(*this->L_Janela,false,false,2);
				if (!((this->n_acesso == 0)||(this->caixa)))
					{
					this->CBP_Funcionario.set_sensitive(false);
					}
				this->CBP_Funcionario.signal_changed().connect(sigc::mem_fun(*this,&RECIBO::selecionar_funcionario));
				this->HP_Funcionario.pack_start(this->CBP_Funcionario,false,false,2);
				//TESTE = new Gtk::Button("Checagem de Ano");
				//TESTE->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::checar_ano),1));
				//this->HP_Funcionario.pack_start(*TESTE,false,false,0);
				this->L_Janela = new Gtk::Label("Expediente: ");
				this->HP_Funcionario.pack_start(*this->L_Janela,false,false,2);
				this->HP_Funcionario.pack_start(this->L_Data,false,false,2);
				if ((this->n_acesso == 0)||(this->caixa))
					{
					this->BT_Ultimos.set_label (Glib::ustring("Últimos"));
					this->BT_Ultimos.signal_clicked ().connect (sigc::mem_fun(*this,&RECIBO::ultimos_recibos));
					//Ação da tela de últimos
					this->HP_Funcionario.pack_start(this->BT_Ultimos,false,false,2);
					}
				this->HP_Movimento.set_homogeneous(false);
				this->HP_Movimento.set_spacing(false);
				// Frame Movimento
				this->F_Janela = new Gtk::Frame(Glib::ustring("Movimento"));
				this->VB_Janela = new Gtk::VBox(false,0);
				this->HB_Janela = new Gtk::HBox(false,0);
				this->L_Janela = new Gtk::Label(Glib::ustring("Data:"));
				this->VB_Janela->pack_start(*this->HB_Janela,false,false);
				this->HB_Janela->pack_start(*this->L_Janela,false,false);
				this->HB_Janela->pack_start(this->CBP_Datas,false,false);
				this->BT_Janela = new Gtk::Button(Glib::ustring("Gerar"));
				this->BT_Janela->set_size_request(100,28);
				this->BT_Janela->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::relatorio),1));
				this->HB_Janela->pack_start(*this->BT_Janela,false,false,0);
				this->F_Janela->add(*this->VB_Janela);
				this->HP_Movimento.pack_start(*this->F_Janela,true,true,0);
				// Frame Recibos
				this->F_Janela = new Gtk::Frame(Glib::ustring("Emissão de Recibos"));
				this->VB_Janela = new Gtk::VBox(false,0);
				this->HB_Janela = new Gtk::HBox(true,10);
				this->BT_Janela = new Gtk::Button(Glib::ustring("Entrada"));
				this->BT_Janela->set_size_request(100,28);
				this->BT_Janela->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::gerar_recibo),1));
				this->HB_Janela->pack_start(*this->BT_Janela,false,false,0);
				this->BT_Janela = new Gtk::Button(Glib::ustring("Entrada-Título"));
				this->BT_Janela->set_size_request(100,28);
				this->BT_Janela->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::gerar_recibo),3));
				this->HB_Janela->pack_start(*this->BT_Janela,false,false,0);
				this->BT_Janela = new Gtk::Button(Glib::ustring("Saída"));
				this->BT_Janela->set_size_request(100,28);
				this->BT_Janela->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::gerar_recibo),2));
				this->BT_Janela->set_sensitive(false);
				if ((this->n_acesso == 0)||(this->caixa))
					{
					this->BT_Janela->set_sensitive(true);
					}
				this->HB_Janela->pack_start(*this->BT_Janela,false,false,0);
				this->BT_Reimprimir.set_label(Glib::ustring("Editar Recibo"));
				this->BT_Reimprimir.set_size_request(100,28);
				//this->BT_Reimprimir.set_sensitive(false);
				this->BT_Reimprimir.signal_clicked ().connect(sigc::mem_fun(*this,&RECIBO::editar_recibo));
				/*if ((this->n_acesso == 0)||(this->caixa))
					{
					this->BT_Reimprimir.set_sensitive(true);
					}*/
				this->HB_Janela->pack_start(this->BT_Reimprimir,false,false,0);
				this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
				this->F_Janela->add(*this->VB_Janela);
				this->HP_Movimento.pack_start(*this->F_Janela,false,true,0);
				//Resumos
				this->HP_Resumos.set_homogeneous(false);
				this->HP_Resumos.set_spacing(false);
				this->F_Janela = new Gtk::Frame(Glib::ustring("Últimos Recibos"));
				this->S_Recibos.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->S_Recibos.add(this->T_Recibos);
				this->T_Recibos.signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::selecionado));
				this->F_Janela->add(this->S_Recibos);
				this->HP_Resumos.pack_start(*this->F_Janela,true,true,0);
				this->F_Janela = new Gtk::Frame(Glib::ustring("Resumo do Dia"));
				this->S_Resumo.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
				this->S_Resumo.add(this->T_Resumo);
				this->F_Janela->add(this->S_Resumo);
				this->HP_Resumos.pack_start(*this->F_Janela,true,true,0);
				this->B_Principal.pack_start(this->HP_Funcionario,false,false,0);
				this->B_Principal.pack_start(this->HP_Movimento,false,true,0);
				this->B_Principal.pack_start(this->HP_Resumos,true,true,0);
				this->Principal.add(this->B_Principal);				
				
				this->Principal.show_all();
				Gtk::Main::run(this->Principal);
				}
			else
				{
				this->Principal.show_all();
				Gtk::Main::run(this->Principal);
				}
			break;
			}
		}
	}

/**
 * Lista os funcionários do sistema para consulta na tela de Principal do Recibo.\n
 * Os níveis mais altos conseguem acessar essa ComboBoxText, para o nível normal ela
 * é bloqueada.
 */
void RECIBO::listagem_funcionario()
	{
	string SQL;
	char *sql, *aux;
	int registro, colunas, i, cod_sel, sel;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
		
	switch(this->janela)
		{
		case 1:
			{
			SQL.clear();
			SQL = "select cod_fun, nome from cadastro.funcionario order by nome";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			registro = this->conexao->registros;
			colunas = this->conexao->colunas;
			arvore_ref = Gtk::ListStore::create(arvore_reg);
			this->CBP_Funcionario.clear();
			this->CBP_Funcionario.set_model(arvore_ref);
			sel = 0;
			conexao->resultado();
			for (i=0,ir=conexao->resultados.begin(); i < registro, ir < conexao->resultados.end(); i++, ir++)
				{
				linha = *ir;
				celula = *(arvore_ref->append());
				cod_sel = atoi(linha.at(0).c_str());
				celula[arvore_reg.cod_func] = cod_sel;
				celula[arvore_reg.descricao]= linha.at(1);
				if (cod_sel == this->cod_fun)
					{
					sel = i;
					}
				}
			this->CBP_Funcionario.set_active(sel);
			break;
			}
		}
	}

/**
 * \param caminho passagem por referência da linha do TreeViewColumn que foi clicado
 * \param coluna Coluna da TreeViewColumn.
 */
void RECIBO::selecionado(const Gtk::TreeModel::Path& caminho, Gtk::TreeViewColumn* coluna)
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	Glib::ustring AUX;
	IMPRIMIR *reimprimir;

	contador =  this->dados_rec->get_iter(caminho);
	if (contador)
		{
		registro = *contador;
		if (registro)
			{
			//this->BT_Reimprimir.set_sensitive(true);
			if ((this->n_acesso == 0)||(this->caixa))
				{
				reimprimir = new IMPRIMIR(this->conexao,registro[arvore_reg.tipo],registro[arvore_reg.data],registro[arvore_reg.n_recibo]);
				}
			else
				{
				reimprimir = new IMPRIMIR(this->conexao,registro[arvore_reg.tipo],registro[arvore_reg.data],registro[arvore_reg.n_recibo],true);
				}
			}
		}
	}

/**
 * Serão listados os últimos 15 recibos emitidos no último dia de movimento do funcionário logado/selecionado. 
 */
void RECIBO::carregar_recibos(int funcionario)
	{
	char *sql, *aux_n;
	string SQL, aux;
	int registro, colunas, i,j,x, it;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	SQL.clear();
	SQL = "select lancamentos.data, lancamentos.rec, clientes.nome, lancamentos.total, lancamentos.e_s, lancamentos.tipo from caixa.lancamentos natural join cadastro.clientes where lancamentos.cod_fun=";
	aux_n = new char[5];
	sprintf(aux_n,"%d",funcionario);
  	SQL.append(aux_n);
	SQL += " and lancamentos.data='" +this->data_sel+ "' and lancamentos.status order by lancamentos.data desc, lancamentos.rec desc limit 15 offset 0";
	delete aux_n;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		registro = this->conexao->registros;
		colunas = this->conexao->colunas;
		dados_rec = Gtk::ListStore::create(arvore_reg);
		this->T_Recibos.set_model(dados_rec);
		conexao->resultado();
		for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
			{
			linha = *ir;
			celula = *(dados_rec->append());
			celula[arvore_reg.data] = linha.at(0);
			celula[arvore_reg.n_recibo] = atoi(linha.at(1).c_str());
			celula[arvore_reg.tipo] = atoi(linha.at(4).c_str());
			celula[arvore_reg.campo[0]]= linha.at(1);
			celula[arvore_reg.campo[1]]= linha.at(2);
			aux.clear();
			aux = linha.at(3);
			it = aux.find(".");
			if (it != string::npos)
				{
				aux.replace(it,1,",");
				}
			celula[arvore_reg.campo_num]= atof(aux.c_str());
			if (celula[arvore_reg.tipo] == 2)
				{
				celula[arvore_reg.campo[2]] = "S";
				}
			else
				{
				celula[arvore_reg.campo[2]] = linha.at(5);
				}
			}
		this->T_Recibos.remove_all_columns();
		this->T_Recibos.append_column(Glib::ustring("Recibo"), arvore_reg.campo[0]);
		this->T_Recibos.append_column(Glib::ustring("Cliente"), arvore_reg.campo[1]);
		this->T_Recibos.append_column_numeric(Glib::ustring("Valor R$"), arvore_reg.campo_num,"%.2f");
		this->T_Recibos.append_column (Glib::ustring("Tipo"), arvore_reg.campo[2]);
		for(i=0; i < colunas-2; i++)
			{
			Gtk::TreeView::Column* coluna_temp = this->T_Recibos.get_column(i);
			coluna_temp->set_reorderable();	
			}
		}
	}

/**
 * As datas serão listadas em um ComboBoxText e são filtradas pelo funcionário.
 * \param funcionario refere-se ao funcionário logado/selecionado.
 */
void RECIBO::listar_datas(int funcionario)
	{
	char *sql1, *aux_n;
	string SQL, aux;
	int registro, sel, i,j,x, it;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	aux_n = new char[10];
	sprintf(aux_n,"%d",funcionario);
	SQL.clear();
	SQL = "select data from caixa.lancamentos where cod_fun=";
	SQL.append(aux_n);
	delete aux_n;
	SQL += " group by data order by data desc limit 15 offset 0";
	sql1 = new char[SQL.length()+1];
	strcpy(sql1,SQL.c_str());
	this->conexao->executar(sql1);
	delete sql1;
	registro = this->conexao->registros;
	arvore_ref = Gtk::ListStore::create(arvore_reg);
	this->CBP_Datas.clear();
	this->CBP_Datas.set_model(arvore_ref);
	sel = 0;
	conexao->resultado();
	for (i=0,ir=conexao->resultados.begin();i < registro, ir < conexao->resultados.end(); i++,ir++)
		{
		linha = *ir;
		celula = *(arvore_ref->append());
		aux_n = new char[20];
		strcpy(aux_n,linha.at(0).c_str());
		celula[arvore_reg.descricao] = data_formatada(aux_n,2);
		delete aux_n;
		celula[arvore_reg.data]= linha.at(0);
		if (this->data_sel.compare(linha.at(0)) == 0)
			{
			sel = i;
			}
		}
	this->CBP_Datas.set_active(sel);
	}

/**
 * É carregado as informações na tela Principal sobre as datas de movimentação,
 * últimos recibos emitidos no último dia de trabalho e resumo dos serviços do último dia de trabalho
 */
void RECIBO::selecionar_funcionario()
	{
	char *aux_dt;
	string aux;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	contador = this->CBP_Funcionario.get_active();
	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			this->cod_fun_sel=registro[arvore_reg.cod_func];
			this->ultima_data(registro[arvore_reg.cod_func]);
			aux.clear();
			aux = "<b>";
			aux_dt = new char[this->data_sel.length()+1];
			strcpy(aux_dt,this->data_sel.c_str());
			aux.append(data_formatada(aux_dt,2));
			delete aux_dt;
			aux += "</b>";
			this->L_Data.set_markup(aux);
			this->listar_datas(registro[arvore_reg.cod_func]);
			this->carregar_recibos(registro[arvore_reg.cod_func]);
			this->carregar_resumo(registro[arvore_reg.cod_func]);
			}
		}
	}

/**
 * É carregado conforme o código do funcionário logado/selecionado, os dados sobre os
 * serviços realizados no último dia de trabalho do mesmo. Tudo é carregado em uma TreeViewColumn.
 * \param funcionario código do funcionário logado/selecionado.
 */
void RECIBO::carregar_resumo(int funcionario)
	{
	char *sql, *aux;
	string SQL, AUX;
	int registro, colunas, i, it, selos;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	SQL.clear();
	SQL = "select servicos.descricao, sum(entrada.qtd) as quantidade, servicos.cod_serv from caixa.lancamentos inner join caixa.entrada on lancamentos.e_s=entrada.e_s and lancamentos.rec=entrada.rec and lancamentos.data=entrada.data inner join cadastro.servicos on entrada.cod_serv=servicos.cod_serv where lancamentos.status and lancamentos.cod_fun=";
	aux = new char[10];
	sprintf(aux,"%d",funcionario);
	SQL.append(aux);
	delete aux;
	SQL += " and lancamentos.data='" +this->data_sel+ "' group by servicos.descricao,servicos.cod_serv order by servicos.descricao";
	//cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
	  	{
		registro = this->conexao->registros;
		colunas =  this->conexao->colunas;
		arvore_ref = Gtk::ListStore::create(arvore_reg);
		this->T_Resumo.set_model(arvore_ref);
		conexao->resultado();
		for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
			{
			linha = *ir;
			celula = *(arvore_ref->append());
			celula[arvore_reg.campo[0]] = linha.at(0);
			celula[arvore_reg.campo_int] = atoi(linha.at(1).c_str());
			celula[arvore_reg.campo_int2] = this->contar_selos(atoi(linha.at(2).c_str()));
			}
		this->T_Resumo.remove_all_columns();
		this->T_Resumo.append_column(Glib::ustring("Serviço"), arvore_reg.campo[0]);
		this->T_Resumo.append_column_numeric(Glib::ustring("Quantidade"), arvore_reg.campo_int,"%d");
		this->T_Resumo.append_column_numeric(Glib::ustring("Selos"), arvore_reg.campo_int2,"%d");
		for(i=0; i < colunas; i++)
			{
			Gtk::TreeView::Column* coluna_temp = this->T_Resumo.get_column(i);
			coluna_temp->set_reorderable();	
			}
		}
	}

/**
 * É carregado todas as informações do funcionário logado no sistema.
 */
void RECIBO::carregar_primeiro()
	{
	this->listagem_funcionario();
	}

/**
 * Conforme o funcionário logado e o tipo do relatório selecionado será carregado no
 * o referido.
 * \param tipo código com o tipo de relatório selecionado.
 */
void RECIBO::relatorio(int tipo)
	{
	string aux;
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	contador = this->CBP_Datas.get_active();
	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			aux.clear();
			aux = registro[arvore_reg.data];
			}
		}
	RELATORIO *relator;
	relator =  new RELATORIO(this->conexao,this->cod_fun_sel,tipo);
	relator->data_relatorio[0].append(aux);
	relator->janela();
	}

/**
 * Conforme o código passado é carregada a tela do Recibo de entrada, entrada de título ou saída.
 * \param e_s tipo de recibo que será gerado pode assumir 3 valores: \n 
 * 1-Entrada \n 
 * 2-Saída \n 
 * 3-Entrada de Título \n 
 * 4-Re-Imprimir Recibo.
 */
void RECIBO::gerar_recibo(int e_s)
	{
	string AUX, aux2, HORA("17:10:00");
	char *aux, *hora;
	Gtk::Button *AUX_BT;
	int checar_hora;

	hora = new char[9];
	hora = agora();
	checar_hora = HORA.compare (hora);
	//cout << e_s << endl;
	this->s_issqn = false;
	this->alterado = false;
	this->itens = 0;
	this->vlr_desc = this->vlr_total = this->vlr_funjecc = this->vlr_issqn = this->vlr_subtotal = 0.0;
	this->Recibo =  new Gtk::Window();
	this->Recibo->set_icon(this->ponteiro_icon);
	this->Recibo->set_type_hint(Gdk::WINDOW_TYPE_HINT_NORMAL);
	this->Recibo->set_position(Gtk::WIN_POS_CENTER);
	this->Recibo->signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),2));
	//Box Principal
	this->Rec_Principal = new Gtk::VBox(false,0);
	switch(e_s)
		{
		case 1:
			{
			this->Recibo->set_size_request(500,500);
			this->Recibo->set_title(Glib::ustring("Recibo de Entrada"));
			//Dados do Cliente
			this->F_Janela = new Gtk::Frame("Dados do Cliente");
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_ConsDoc = new Gtk::Button(Glib::ustring("Consultar Documento"));
			this->Rec_ConsDoc->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::consultar_dados),1));
			this->HB_Janela->pack_start (*this->Rec_ConsDoc,false,false,0);
			this->Rec_ConsFic = new Gtk::Button(Glib::ustring("Consultar Ficha"));
			this->Rec_ConsFic->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::consultar_dados),2));
			this->HB_Janela->pack_start (*this->Rec_ConsFic,false,false,0);
			this->B_Cred = new Gtk::CheckButton ("Crédito");
			if (checar_hora <= 0)
				{
				this->B_Cred->set_active(true);
				this->B_Cred->set_sensitive(false);
				}
			this->HB_Janela->pack_start (*this->B_Cred,false,false,0);
			Ato_Gratuito = new Gtk::CheckButton ("Ato Gratuito");
			//Ato_Gratuito->set_active (ato_gratuito);
			HB_Janela->pack_start(*Ato_Gratuito,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			AUX_BT = new Gtk::Button(Glib::ustring("..."));
			AUX_BT->signal_clicked ().connect (sigc::mem_fun(*this,&RECIBO::consultar_cliente));
			this->Rec_CliCod = new Gtk::Entry();
			this->Rec_CliCod->set_size_request(70,26);
			this->Rec_CliCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),1));
			this->Rec_CliCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),1,e_s));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*AUX_BT,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_CliCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Nome: "));
			this->Rec_Cliente = new Gtk::Entry();
			this->Rec_Cliente->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),1));
			this->EntryCliente = Gtk::EntryCompletion::create();
			this->Rec_Cliente->set_completion(this->EntryCliente);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryCliente->set_model(this->dados_ref);
			this->Rec_Cliente->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_clienteE),e_s));
			this->preparar_dados(1,e_s);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Cliente,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Endereço: "));
			this->Rec_End = new Gtk::Entry();
			this->Rec_End->set_editable(false);
			this->Rec_End->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),2));
			this->Rec_End->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),1));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_End,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Documento: "));
			this->Rec_Doc = new Gtk::Entry();
			this->Rec_Doc->set_editable(false);
			this->Rec_Doc->set_size_request(120,26);
			this->Rec_Doc->set_max_length(14);
			this->Rec_Doc->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),2));
			this->Rec_Doc->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::novo_cliente),e_s));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Doc,true,true,0);
			this->Rec_Natureza = new Gtk::Label("Natureza: ");
			this->HB_Janela->pack_start(*this->Rec_Natureza,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			//Observações
			this->F_Janela = new Gtk::Frame("Observações");
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_OBS = new Gtk::Entry();
			this->HB_Janela->pack_start(*this->Rec_OBS,true,true,0);
			this->F_Janela->add(*this->HB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			// Serviços
			this->F_Janela = new Gtk::Frame(Glib::ustring("Cadastro de Serviço"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerCod = new Gtk::Entry();
			this->Rec_OBS->signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::tabulacao),this->Recibo,this->Rec_SerCod));
			this->Rec_SerCod->set_size_request(60,26);
			this->Rec_SerCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),3));
			this->Rec_SerCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),2,e_s));
			this->HB_Janela->pack_start(*this->Rec_SerCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Descrição: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_Servico = new Gtk::Entry();
			this->Rec_Servico->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),3));
			this->EntryServico = Gtk::EntryCompletion::create();
			this->Rec_Servico->set_completion(this->EntryServico);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryServico->set_model(this->dados_ref);
			this->Rec_Servico->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_servicoE),1));
			this->preparar_dados(2,e_s);
			this->HB_Janela->pack_start(*this->Rec_Servico,true,true,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Quantidade: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerQtd = new Gtk::Entry();
			this->Rec_SerQtd->set_size_request(60,27);
			this->Rec_SerQtd->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),4));
			this->Rec_SerQtd->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),2));
			this->HB_Janela->pack_start(*this->Rec_SerQtd,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Unitário: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerVUni = new Gtk::Entry();
			this->Rec_SerVUni->set_size_request(70,27);
			this->Rec_SerVUni->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),1));
			this->HB_Janela->pack_start(*this->Rec_SerVUni,false,false,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			//this->L_Janela = new Gtk::Label(Glib::ustring("Desconto:"));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerDesc = new Gtk::Entry();
			Rec_SerDesc->set_text("0,0");
			this->Rec_SerDesc->set_size_request(100,27);
			this->Rec_SerDesc->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),5));
			this->Rec_SerDesc->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),2));
			//this->HB_Janela->pack_start(*this->Rec_SerDesc,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Total R$ "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerValor = new Gtk::Entry();
			this->Rec_SerValor->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerValor,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_CadServ = new Gtk::Button(Gtk::Stock::ADD);
			this->Rec_CadServ->set_sensitive(false);
			this->Rec_CadServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->Rec_DelServ = new Gtk::Button(Gtk::Stock::REMOVE);
			this->Rec_DelServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::remover_servico));
			this->Rec_DelServ->set_sensitive(false);
			this->Rec_AltServ = new Gtk::Button(Gtk::Stock::APPLY);
			this->Rec_AltServ->set_sensitive(false);
			this->Rec_AltServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->HB_Janela->pack_start(*this->Rec_CadServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_DelServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_AltServ,false,false,5);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);				
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->F_Janela = new Gtk::Frame(Glib::ustring("Detalhe do Recibo"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->Rec_Scroll = new Gtk::ScrolledWindow();
			this->Rec_Scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
			this->Rec_Dados = new Gtk::TreeView();
			this->Rec_Scroll->add(*this->Rec_Dados);
			this->dados_serv = Gtk::ListStore::create(this->dados_arv);
			this->Rec_Dados->set_model(this->dados_serv);
			this->Rec_Dados->remove_all_columns();
			this->Rec_Dados->append_column(Glib::ustring("Código"), dados_arv.campo[0]);
			this->Rec_Dados->append_column(Glib::ustring("Serviço"), dados_arv.campo[1]);
			this->Rec_Dados->append_column(Glib::ustring("Quantidade"), dados_arv.campo[2]);
			this->Rec_Dados->append_column(Glib::ustring("Valor"), dados_arv.campo[3]);
			this->Rec_Dados->append_column(Glib::ustring("Desconto"), dados_arv.campo[4]);
			this->Rec_Dados->append_column(Glib::ustring("Funjecc"), dados_arv.campo[5]);
			this->Rec_Dados->append_column(Glib::ustring("ISSQN"), dados_arv.campo[6]);
			for(int i=0; i < 7; i++)
				{
				Gtk::TreeView::Column* coluna_temp = this->Rec_Dados->get_column(i);
				coluna_temp->set_reorderable();	
				}
			this->Rec_Dados->signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::selecionar_servico));
			this->VB_Janela->pack_start(*this->Rec_Scroll,true,true,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[0] = new Gtk::Label(Glib::ustring("SubTotal R$:   "));
			this->Rec_SubT = new Gtk::Entry();
			this->Rec_SubT->set_size_request (100,27);
			this->Rec_SubT->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_DadosL[0],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_SubT,false,false,0);
			this->Rec_DadosL[1] = new Gtk::Label(Glib::ustring("  Funjecc 10% R$: "));
			this->Rec_Funjecc = new Gtk::Entry();
			this->Rec_Funjecc->set_editable (false);
			this->Rec_Funjecc->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[1],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Funjecc,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[2] = new Gtk::Label(Glib::ustring("Desconto R$: "));
			this->Rec_Desconto = new Gtk::Entry();
			Rec_Desconto->set_text("0,0");
			this->Rec_Desconto->set_editable (false);
			this->Rec_Desconto->set_size_request (100,27);
			//this->HB_Janela->pack_start(*this->Rec_DadosL[2],false,false,0);
			//this->HB_Janela->pack_start(*this->Rec_Desconto,false,false,0);
			this->Rec_DadosL[3] = new Gtk::Label(Glib::ustring("  ISSQN R$:           "));
			this->Rec_ISSQN = new Gtk::Entry();
			this->Rec_ISSQN->set_editable (false);
			this->Rec_ISSQN->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[3],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_ISSQN,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[4] = new Gtk::Label(Glib::ustring("Total R$:         "));
			this->Rec_Total = new Gtk::Entry();
			this->Rec_Total->set_editable (false);
			this->Rec_Total->set_size_request (100,-1);
			//this->Rec_Total->get_layout()->set_markup("<i>Teste</i>");
			this->HB_Janela->pack_start(*this->Rec_DadosL[4],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Total,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_GERAR = new Gtk::Button("Gerar Recibo");
			this->Rec_GERAR->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_campos),e_s));
			this->HB_Janela->pack_start(*this->Rec_GERAR,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Recibo Número:"));
			this->Rec_NUMERO = new Gtk::Entry();
			this->Rec_NUMERO->set_size_request(100,27);
			this->Rec_NUMERO->set_editable(false);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->HB_Janela->pack_start(*this->Rec_NUMERO,false,false,0);
			this->Rec_IMPRIMIR = new Gtk::Button(Gtk::Stock::PRINT);
			this->Rec_IMPRIMIR->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::imprimir),e_s));
			this->Rec_IMPRIMIR->set_sensitive(false);
			this->HB_Janela->pack_start(*this->Rec_IMPRIMIR,false,false,0);
			this->Rec_Principal->pack_start(*this->HB_Janela,false,false,0);
			this->Recibo->set_focus (*this->Rec_CliCod);
			break;
			}
		case 2:
			{
			this->saida_pagina=0;
			this->Recibo->set_size_request(550,-1);
			this->Recibo->set_title(Glib::ustring("Recibo de Saída"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->Rec_SaidaT = new Gtk::Toolbar ();
			this->Rec_SaidaTB[0] = new Gtk::ToolButton (Gtk::Stock::NEW);
			this->Rec_SaidaTB[0]->set_tooltip_text ("Novo");
			this->Rec_SaidaTB[0]->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::saida_acao),1));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[0]);
			this->Rec_SaidaTB[1] = new Gtk::ToolButton (Gtk::Stock::EDIT);
			this->Rec_SaidaTB[1]->set_tooltip_text ("Editar");
			this->Rec_SaidaTB[1]->signal_clicked ().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::saida_acao),2));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[1]);
			this->Rec_SaidaTB[6] = new Gtk::ToolButton (Gtk::Stock::CANCEL);
			this->Rec_SaidaTB[6]->set_tooltip_text ("Cancelar Ação");
			this->Rec_SaidaTB[6]->set_sensitive (false);
			this->Rec_SaidaTB[6]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_acao),0));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[6]);
			this->Rec_SaidaTB[7] = new Gtk::ToolButton (Gtk::Stock::REMOVE);
			this->Rec_SaidaTB[7]->set_tooltip_text ("Deletar");
			this->Rec_SaidaTB[7]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_acao),3));
			this->Rec_SaidaTB[7]->set_sensitive (false);
			if (this->caixa)
				{
				this->Rec_SaidaTB[7]->set_sensitive (true);
				}
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[7]);
			this->Rec_SaidaTB[2] = new Gtk::ToolButton (Gtk::Stock::GOTO_FIRST);
			this->Rec_SaidaTB[2]->set_tooltip_text ("Primeiro");
			this->Rec_SaidaTB[2]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_navegar),4));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[2]);
			this->Rec_SaidaTB[3] = new Gtk::ToolButton (Gtk::Stock::GO_BACK);
			this->Rec_SaidaTB[3]->set_tooltip_text ("Anterior");
			this->Rec_SaidaTB[3]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_navegar),3));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[3]);
			this->Rec_SaidaTI = new Gtk::ToolItem ();
			this->Rec_SaidaTE = new Gtk::Entry();
			this->Rec_SaidaTE->set_size_request (150,-1);
			this->Rec_SaidaTE->set_editable (false);
			this->Rec_SaidaTE->set_alignment (Gtk::ALIGN_CENTER);
			this->Rec_SaidaTI->add(*this->Rec_SaidaTE);
			this->Rec_SaidaT->append(*this->Rec_SaidaTI);
			this->Rec_SaidaTB[4] = new Gtk::ToolButton (Gtk::Stock::GO_FORWARD);
			this->Rec_SaidaTB[4]->set_tooltip_text ("Próximo");
			this->Rec_SaidaTB[4]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_navegar),2));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[4]);
			this->Rec_SaidaTB[5] = new Gtk::ToolButton (Gtk::Stock::GOTO_LAST);
			this->Rec_SaidaTB[5]->set_tooltip_text ("Último");
			this->Rec_SaidaTB[5]->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun (*this,&RECIBO::saida_navegar),1));
			this->Rec_SaidaT->append(*this->Rec_SaidaTB[5]);
			this->Rec_SaidaTI = new Gtk::ToolItem ();
			this->Rec_SaidaTL = new Gtk::Label();
			this->Rec_SaidaTI->add(*this->Rec_SaidaTL);
			this->Rec_SaidaT->append(*this->Rec_SaidaTI);
			this->VB_Janela->pack_start(*this->Rec_SaidaT,false,false,0);
			this->Rec_Principal->pack_start(*this->VB_Janela,false,false,0);
			//Dados do Cliente
			this->F_Janela = new Gtk::Frame("Dados Pagamento");
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->Rec_CliCod = new Gtk::Entry();
			this->Rec_CliCod->set_editable (false);
			this->Rec_CliCod->set_size_request(70,-1);
			this->Rec_CliCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),1));
			this->Rec_CliCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),1,e_s));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_CliCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Nome: "));
			this->Rec_Cliente = new Gtk::Entry();
			this->Rec_Cliente->set_editable (false);
			this->Rec_Cliente->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),1));
			this->EntryCliente = Gtk::EntryCompletion::create();
			this->Rec_Cliente->set_completion(this->EntryCliente);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryCliente->set_model(this->dados_ref);
			this->Rec_Cliente->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_clienteE),e_s));
			this->preparar_dados(1,e_s);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Cliente,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->F_Janela = new Gtk::Frame(Glib::ustring("Cadastro de Histórico"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerCod = new Gtk::Entry();
			this->Rec_SerCod->set_editable (false);
			this->Rec_SerCod->set_size_request(60,-1);
			this->Rec_SerCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),3));
			this->Rec_SerCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),2,e_s));
			this->HB_Janela->pack_start(*this->Rec_SerCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Histórico: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_Servico = new Gtk::Entry();
			this->Rec_Servico->set_editable (false);
			this->Rec_Servico->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),3));
			this->EntryServico = Gtk::EntryCompletion::create();
			this->Rec_Servico->set_completion(this->EntryServico);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryServico->set_model(this->dados_ref);
			this->Rec_Servico->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_servicoE),2));
			this->preparar_dados(2,e_s);
			this->HB_Janela->pack_start(*this->Rec_Servico,true,true,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Referente: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->RecSer_Hist = new Gtk::Entry();
			this->RecSer_Hist->set_editable (false);
			this->RecSer_Hist->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),4));
			this->RecSer_Hist->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),3));
			this->EntryHistorico = Gtk::EntryCompletion::create();
			this->RecSer_Hist->set_completion(this->EntryHistorico);
			this->dados_historico = Gtk::ListStore::create(this->dados_arv);
			this->EntryHistorico->set_model(this->dados_historico);
			//this->RecSer_Hist->signal_activate().connect(sigc::mem_fun(*this,&RECIBO::checar_historico));
			this->preparar_dados(3,e_s);
			this->HB_Janela->pack_start(*this->RecSer_Hist,true,true,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor R$: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_Total = new Gtk::Entry();
			this->Rec_Total->set_editable (false);
			this->Rec_Total->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),6));
			this->Rec_Total->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),4));
			this->HB_Janela->pack_start(*this->Rec_Total,false,false,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_GERAR = new Gtk::Button("Salvar Novo");
			this->Rec_GERAR->set_sensitive (false);
			this->Rec_GERAR->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::saida),0));
			this->HB_Janela->pack_start(*this->Rec_GERAR,false,false,1);
			this->Rec_SALVAR = new Gtk::Button("Salvar Edição");
			this->Rec_SALVAR->set_sensitive (false);
			this->Rec_SALVAR->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::saida),1));
			this->HB_Janela->pack_start(*this->Rec_SALVAR,false,false,1);
			this->Rec_SaidaStatus = new Gtk::Label("");
			this->HB_Janela->pack_start(*this->Rec_SaidaStatus,false,false,1);
			this->Rec_Principal->pack_start(*this->HB_Janela,false,false,0);
			this->carregar_saida ();
			break;
			}
		case 3:
			{
			this->Recibo->set_size_request(500,500);
			this->Recibo->set_title(Glib::ustring("Recibo de Entrada - Títulos"));
			//Dados do Protocolo
			this->F_Janela = new Gtk::Frame("Busca de Protocolo");
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Prot_Data = new Gtk::Entry ();
			this->Prot_Data->set_max_length (10);
			this->Prot_Data->set_size_request (85,-1);
			this->Prot_Data->signal_changed().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::data_mascara),2));
			//carregar datas do sistema
			this->EntryProtData = Gtk::EntryCompletion::create();
			this->Prot_Data->set_completion(this->EntryProtData);
			this->dados_protdata = Gtk::ListStore::create(this->dados_arv);
			this->EntryProtData->set_model(this->dados_protdata);
			this->preparar_dados(4,e_s);
			this->Prot_Numero = new Gtk::Entry();
			this->Prot_Numero->set_size_request (90,-1);
			this->EntryProtNum = Gtk::EntryCompletion::create();
			this->Prot_Numero->set_completion(this->EntryProtNum);
			this->dados_protnum = Gtk::ListStore::create(this->dados_arv);
			this->EntryProtNum->set_model(this->dados_protnum);
			this->Prot_Numero->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),3,e_s));
			this->Prot_Data->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::preparar_dados),5,e_s));
			this->L_Janela = new Gtk::Label("Data: ");
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Prot_Data,false,false,0);
			this->L_Janela = new Gtk::Label("Protocolo: ");
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Prot_Numero,false,false,0);
			Ato_Gratuito = new Gtk::CheckButton ("Ato Gratuito");
			//Ato_Gratuito->set_active (ato_gratuito);
			HB_Janela->pack_start(*Ato_Gratuito,false,false,0);
			this->F_Janela->add(*this->HB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->B_Cred = new Gtk::CheckButton ("Crédito");
			if (checar_hora <= 0)
				{
				this->B_Cred->set_active(true);
				//this->B_Cred->set_sensitive(false);
				}
			//Dados do Apresentante
			this->F_Janela = new Gtk::Frame("Dados do Apresentante");
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->Rec_CliCod = new Gtk::Entry();
			this->Rec_CliCod->set_size_request(70,26);
			this->Rec_CliCod->set_editable (false);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_CliCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Nome: "));
			this->Rec_Cliente = new Gtk::Entry();
			this->Rec_Cliente->set_editable (false);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Cliente,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Endereço: "));
			this->Rec_End = new Gtk::Entry();
			this->Rec_End->set_editable(false);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_End,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			//Observações
			this->F_Janela = new Gtk::Frame("Observações");
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_OBS = new Gtk::Entry();
			this->HB_Janela->pack_start(*this->Rec_OBS,true,true,0);
			this->F_Janela->add(*this->HB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			// Serviços
			this->F_Janela = new Gtk::Frame(Glib::ustring("Cadastro de Serviço"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerCod = new Gtk::Entry();
			this->Rec_OBS->signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::tabulacao),this->Recibo,this->Rec_SerCod));				
			this->Rec_SerCod->set_size_request(60,26);
			this->Rec_SerCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),3));
			this->Rec_SerCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),2,e_s));
			this->HB_Janela->pack_start(*this->Rec_SerCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Descrição: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_Servico = new Gtk::Entry();
			this->Rec_Servico->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),3));
			this->EntryServico = Gtk::EntryCompletion::create();
			this->Rec_Servico->set_completion(this->EntryServico);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryServico->set_model(this->dados_ref);
			this->Rec_Servico->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_servicoE),1));
			this->preparar_dados(2,e_s);
			this->HB_Janela->pack_start(*this->Rec_Servico,true,true,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Quantidade: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerQtd = new Gtk::Entry();
			this->Rec_SerQtd->set_size_request(60,27);
			this->Rec_SerQtd->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),4));
			this->Rec_SerQtd->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),2));
			this->HB_Janela->pack_start(*this->Rec_SerQtd,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Unitário: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerVUni = new Gtk::Entry();
			this->Rec_SerVUni->set_size_request(70,27);
			this->Rec_SerVUni->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),1));
			this->HB_Janela->pack_start(*this->Rec_SerVUni,false,false,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			//this->L_Janela = new Gtk::Label(Glib::ustring("Desconto:"));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerDesc = new Gtk::Entry();
			Rec_SerDesc->set_text("0,0");
			this->Rec_SerDesc->set_size_request(100,27);
			this->Rec_SerDesc->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),5));
			this->Rec_SerDesc->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),2));
			//this->HB_Janela->pack_start(*this->Rec_SerDesc,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Total R$ "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerValor = new Gtk::Entry();
			this->Rec_SerValor->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerValor,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_CadServ = new Gtk::Button(Gtk::Stock::ADD);
			this->Rec_CadServ->set_sensitive(false);
			this->Rec_CadServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->Rec_DelServ = new Gtk::Button(Gtk::Stock::REMOVE);
			this->Rec_DelServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::remover_servico));
			this->Rec_DelServ->set_sensitive(false);
			this->Rec_AltServ = new Gtk::Button(Gtk::Stock::APPLY);
			this->Rec_AltServ->set_sensitive(false);
			this->Rec_AltServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->HB_Janela->pack_start(*this->Rec_CadServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_DelServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_AltServ,false,false,5);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);				
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->F_Janela = new Gtk::Frame(Glib::ustring("Detalhe do Recibo"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->Rec_Scroll = new Gtk::ScrolledWindow();
			this->Rec_Scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
			this->Rec_Dados = new Gtk::TreeView();
			this->Rec_Scroll->add(*this->Rec_Dados);
			this->dados_serv = Gtk::ListStore::create(this->dados_arv);
			this->Rec_Dados->set_model(this->dados_serv);
			this->Rec_Dados->remove_all_columns();
			this->Rec_Dados->append_column(Glib::ustring("Código"), dados_arv.campo[0]);
			this->Rec_Dados->append_column(Glib::ustring("Serviço"), dados_arv.campo[1]);
			this->Rec_Dados->append_column(Glib::ustring("Quantidade"), dados_arv.campo[2]);
			this->Rec_Dados->append_column(Glib::ustring("Valor"), dados_arv.campo[3]);
			this->Rec_Dados->append_column(Glib::ustring("Desconto"), dados_arv.campo[4]);
			this->Rec_Dados->append_column(Glib::ustring("Funjecc"), dados_arv.campo[5]);
			this->Rec_Dados->append_column(Glib::ustring("ISSQN"), dados_arv.campo[6]);
			for(int i=0; i < 7; i++)
				{
				Gtk::TreeView::Column* coluna_temp = this->Rec_Dados->get_column(i);
				coluna_temp->set_reorderable();	
				}
			this->Rec_Dados->signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::selecionar_servico));
			this->VB_Janela->pack_start(*this->Rec_Scroll,true,true,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[0] = new Gtk::Label(Glib::ustring("SubTotal R$:   "));
			this->Rec_SubT = new Gtk::Entry();
			this->Rec_SubT->set_size_request (100,27);
			this->Rec_SubT->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_DadosL[0],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_SubT,false,false,0);
			this->Rec_DadosL[1] = new Gtk::Label(Glib::ustring("  Funjecc 10% R$: "));
			this->Rec_Funjecc = new Gtk::Entry();
			this->Rec_Funjecc->set_editable (false);
			this->Rec_Funjecc->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[1],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Funjecc,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[2] = new Gtk::Label(Glib::ustring("Desconto R$: "));
			this->Rec_Desconto = new Gtk::Entry();
			Rec_Desconto->set_text("0,0");
			this->Rec_Desconto->set_editable (false);
			this->Rec_Desconto->set_size_request (100,27);
			//this->HB_Janela->pack_start(*this->Rec_DadosL[2],false,false,0);
			//this->HB_Janela->pack_start(*this->Rec_Desconto,false,false,0);
			this->Rec_DadosL[3] = new Gtk::Label(Glib::ustring("  ISSQN R$:           "));
			this->Rec_ISSQN = new Gtk::Entry();
			this->Rec_ISSQN->set_editable (false);
			this->Rec_ISSQN->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[3],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_ISSQN,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[4] = new Gtk::Label(Glib::ustring("Total R$:         "));
			this->Rec_Total = new Gtk::Entry();
			this->Rec_Total->set_editable (false);
			this->Rec_Total->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[4],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Total,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_GERAR = new Gtk::Button("Gerar Recibo");
			this->Rec_GERAR->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_campos),e_s));
			this->HB_Janela->pack_start(*this->Rec_GERAR,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Recibo Número:"));
			this->Rec_NUMERO = new Gtk::Entry();
			this->Rec_NUMERO->set_size_request(100,-1);
			this->Rec_NUMERO->set_editable(false);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->HB_Janela->pack_start(*this->Rec_NUMERO,false,false,0);
			this->Rec_IMPRIMIR = new Gtk::Button(Gtk::Stock::PRINT);
			this->Rec_IMPRIMIR->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::imprimir),1));
			this->Rec_IMPRIMIR->set_sensitive(false);
			this->HB_Janela->pack_start(*this->Rec_IMPRIMIR,false,false,0);
			this->Rec_Principal->pack_start(*this->HB_Janela,false,false,0);
			this->Recibo->set_focus(*this->Prot_Data);
			break;			
			}
		case 4:
			{
			this->Recibo->set_size_request(500,500);
			this->Recibo->set_title(Glib::ustring("Recibo de Entrada - Reimpressão"));
			//Dados do Recibo
			this->F_Janela = new Gtk::Frame("Dados do Recibo");
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label("");
			AUX.clear();
			AUX = "Data: <b>";
			aux = new char[12];
			strcpy(aux,this->data_recibo.c_str());
			AUX.append(data_formatada(aux,2));
			delete aux;
			AUX += "</b>";
			this->L_Janela->set_markup(Glib::ustring(AUX));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->L_Janela = new Gtk::Label("");
			AUX.clear();
			AUX = "Número: <b>"+this->numero_recibo+"</b>";
			this->L_Janela->set_markup(Glib::ustring(AUX));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,20);
			this->Rec_Status =  new Gtk::Label("");
			this->HB_Janela->pack_start(*this->Rec_Status,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_INFO[0] = new Gtk::Label("");
			this->Rec_INFO[1] = new Gtk::Label("");
			this->HB_Janela->pack_start(*this->Rec_INFO[0],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_INFO[1],false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			//Dados do Cliente
			this->F_Janela = new Gtk::Frame("Dados do Cliente");
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->Rec_CliCod = new Gtk::Entry();
			this->Rec_CliCod->set_size_request(70,26);
			this->Rec_CliCod->set_editable(false);
			this->Rec_CliCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),1));
			this->Rec_CliCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),1,1));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_CliCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Nome: "));
			this->Rec_Cliente = new Gtk::Entry();
			this->Rec_Cliente->set_editable(false);
			this->Rec_Cliente->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),1));
			this->EntryCliente = Gtk::EntryCompletion::create();
			this->Rec_Cliente->set_completion(this->EntryCliente);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryCliente->set_model(this->dados_ref);
			this->Rec_Cliente->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_clienteE),1));
			this->preparar_dados(1,1);
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Cliente,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Endereço: "));
			this->Rec_End = new Gtk::Entry();
			this->Rec_End->set_editable(false);
			this->Rec_End->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),2));
			this->Rec_End->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),1));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_End,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Documento: "));
			this->Rec_Doc = new Gtk::Entry();
			this->Rec_Doc->set_editable(false);
			this->Rec_Doc->set_size_request(120,26);
			this->Rec_Doc->set_max_length(14);
			this->Rec_Doc->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),2));
			this->Rec_Doc->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::novo_cliente),1));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Doc,true,true,0);
			this->Rec_Natureza = new Gtk::Label("Natureza: ");
			this->HB_Janela->pack_start(*this->Rec_Natureza,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			//Observações
			this->F_Janela = new Gtk::Frame("Observações");
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_OBS = new Gtk::Entry();
			this->HB_Janela->pack_start(*this->Rec_OBS,true,true,0);
			this->F_Janela->add(*this->HB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			//Dados do Cliente
			this->carregar_dados(1,4);
			// Serviços
			this->F_Janela = new Gtk::Frame(Glib::ustring("Cadastro de Serviço"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Código: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerCod = new Gtk::Entry();
			this->Rec_OBS->signal_activate().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::tabulacao),this->Recibo,this->Rec_SerCod));
			this->Rec_SerCod->set_size_request(60,26);
			this->Rec_SerCod->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),3));
			this->Rec_SerCod->signal_activate().connect(sigc::bind<int,int>(sigc::mem_fun(*this,&RECIBO::carregar_dados),2,1));
			this->Rec_SerCod->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerCod,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Descrição: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_Servico = new Gtk::Entry();
			this->Rec_Servico->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::letra),3));
			this->EntryServico = Gtk::EntryCompletion::create();
			this->Rec_Servico->set_completion(this->EntryServico);
			this->dados_ref = Gtk::ListStore::create(this->dados_arv);
			this->EntryServico->set_model(this->dados_ref);
			this->Rec_Servico->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::checar_servicoE),1));
			this->Rec_Servico->set_editable(false);
			this->preparar_dados(2,1);
			this->HB_Janela->pack_start(*this->Rec_Servico,true,true,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Quantidade: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerQtd = new Gtk::Entry();
			this->Rec_SerQtd->set_size_request(60,27);
			this->Rec_SerQtd->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),4));
			this->Rec_SerQtd->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),2));
			this->Rec_SerQtd->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerQtd,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Unitário: "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerVUni = new Gtk::Entry();
			this->Rec_SerVUni->set_size_request(70,27);
			this->Rec_SerVUni->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),1));
			this->Rec_SerVUni->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerVUni,false,false,1);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			//this->L_Janela = new Gtk::Label(Glib::ustring("Desconto:"));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerDesc = new Gtk::Entry();
			Rec_SerDesc->set_text("0,0");
			this->Rec_SerDesc->set_size_request(100,27);
			this->Rec_SerDesc->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),5));
			this->Rec_SerDesc->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::calcular_valor),2));
			this->Rec_SerDesc->set_editable(false);
			//this->HB_Janela->pack_start(*this->Rec_SerDesc,false,false,0);
			this->L_Janela = new Gtk::Label(Glib::ustring("Valor Total R$ "));
			this->HB_Janela->pack_start(*this->L_Janela,false,false,1);
			this->Rec_SerValor = new Gtk::Entry();
			this->Rec_SerValor->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_SerValor,true,true,0);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_CadServ = new Gtk::Button(Gtk::Stock::ADD);
			this->Rec_CadServ->set_sensitive(false);
			this->Rec_CadServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->Rec_CadServ->set_sensitive(false);
			this->Rec_DelServ = new Gtk::Button(Gtk::Stock::REMOVE);
			this->Rec_DelServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::remover_servico));
			this->Rec_DelServ->set_sensitive(false);
			this->Rec_AltServ = new Gtk::Button(Gtk::Stock::APPLY);
			this->Rec_AltServ->set_sensitive(false);
			this->Rec_AltServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::incluir_servico));
			this->HB_Janela->pack_start(*this->Rec_CadServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_DelServ,false,false,5);
			this->HB_Janela->pack_start(*this->Rec_AltServ,false,false,5);
			this->VB_Janela->pack_start(*this->HB_Janela,true,true,0);				
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,false,true,0);
			this->F_Janela = new Gtk::Frame(Glib::ustring("Detalhe do Recibo"));
			this->VB_Janela = new Gtk::VBox(false,0);
			this->Rec_Scroll = new Gtk::ScrolledWindow();
			this->Rec_Scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
			this->Rec_Dados = new Gtk::TreeView();
			this->Rec_Scroll->add(*this->Rec_Dados);
			this->Rec_Dados->signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::selecionar_servico));
			this->Rec_Dados->set_sensitive(false);
			this->VB_Janela->pack_start(*this->Rec_Scroll,true,true,0);
			//Totalizadores
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[0] = new Gtk::Label(Glib::ustring("SubTotal R$:   "));
			this->Rec_SubT = new Gtk::Entry();
			this->Rec_SubT->set_size_request (100,27);
			this->Rec_SubT->set_editable(false);
			this->HB_Janela->pack_start(*this->Rec_DadosL[0],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_SubT,false,false,0);
			this->Rec_DadosL[1] = new Gtk::Label(Glib::ustring("  Funjecc 10% R$: "));
			this->Rec_Funjecc = new Gtk::Entry();
			this->Rec_Funjecc->set_editable (false);
			this->Rec_Funjecc->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[1],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Funjecc,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[2] = new Gtk::Label(Glib::ustring("Desconto R$: "));
			this->Rec_Desconto = new Gtk::Entry();
			Rec_Desconto->set_text("0,0");
			this->Rec_Desconto->set_editable (false);
			this->Rec_Desconto->set_size_request (100,27);
			//this->HB_Janela->pack_start(*this->Rec_DadosL[2],false,false,0);
			//this->HB_Janela->pack_start(*this->Rec_Desconto,false,false,0);
			this->Rec_DadosL[3] = new Gtk::Label(Glib::ustring("  ISSQN R$:           "));
			this->Rec_ISSQN = new Gtk::Entry();
			this->Rec_ISSQN->set_editable (false);
			this->Rec_ISSQN->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[3],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_ISSQN,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->HB_Janela =  new Gtk::HBox(false,0);
			this->Rec_DadosL[4] = new Gtk::Label(Glib::ustring("Total R$:         "));
			this->Rec_Total = new Gtk::Entry();
			this->Rec_Total->set_editable (false);
			this->Rec_Total->set_size_request (100,27);
			this->HB_Janela->pack_start(*this->Rec_DadosL[4],false,false,0);
			this->HB_Janela->pack_start(*this->Rec_Total,false,false,0);
			this->VB_Janela->pack_start(*this->HB_Janela,false,false,0);
			this->F_Janela->add(*this->VB_Janela);
			this->Rec_Principal->pack_start(*this->F_Janela,true,true,0);
			//Dados dos Serviços e Totalizadores
			this->carregar_dados(2,4);
			//Botões
			this->HB_Janela = new Gtk::HBox(false,0);
			this->Rec_GERAR = new Gtk::Button(Gtk::Stock::EDIT);
			this->Rec_GERAR->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::liberar_alteracao));
			this->Rec_GERAR->set_sensitive(false);
			this->HB_Janela->pack_start(*this->Rec_GERAR,false,false,0);
			this->Rec_SALVAR =  new Gtk::Button(Gtk::Stock::SAVE);
			this->Rec_SALVAR->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::salvar_alteracao));
			this->Rec_SALVAR->set_sensitive(false);
			this->HB_Janela->pack_start(*this->Rec_SALVAR,false,false,0);
			this->Rec_IMPRIMIR = new Gtk::Button(Gtk::Stock::PRINT);
			this->Rec_IMPRIMIR->signal_clicked().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::imprimir),e_s));
			//this->Rec_IMPRIMIR->set_sensitive(false);
			this->HB_Janela->pack_start(*this->Rec_IMPRIMIR,false,false,0);
			this->Rec_CancelServ = new Gtk::Button(Gtk::Stock::CANCEL);
			this->Rec_CancelServ->set_sensitive (false);
			this->Rec_CancelServ->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::cancelar_recibo));
			this->HB_Janela->pack_start(*this->Rec_CancelServ,false,false,0);
			this->Rec_BDebCred = new Gtk::Button(Glib::ustring("Crédito"));
			this->Rec_BDebCred->set_sensitive (false);
			this->Rec_BDebCred->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::voltar_credito));
			this->HB_Janela->pack_start(*this->Rec_BDebCred,false,false,0);
			this->Rec_Principal->pack_start(*this->HB_Janela,false,false,0);
			this->Recibo->set_focus(*this->Rec_GERAR);
			if ((this->caixa)||(this->n_acesso == 0))
				{
				this->Rec_GERAR->set_sensitive(true);
				this->Rec_CancelServ->set_sensitive(true);
				this->Rec_BDebCred->set_sensitive (true);
				}
			this->carregar_dados(4,0);
			break;
			}
		}
	this->Recibo->add(*this->Rec_Principal);
	this->Recibo->show_all();
	Gtk::Main::run(*this->Recibo);
	}

/**
 * Conforme a tela que está aberta e os parâmetros passados é carregados dados do sistema para os campos necessários
 * \param modo é utilizado para determinar que tipo de dado será carregado:\n
 * 1 - Cadastro de Clientes\n
 * 2 - Cadastro de Serviços\n
 * 3 - Dados de Protocolo de Título apontado (dados externos)\n
 * 4 - Status do recibo \n
 * \param tipo é utilizado no caso dos modos 1 e 2, para indicar se são dados de entrada ou saída. Podem assumir 3 valores:\n
 * 1 - Entrada\n
 * 2 - Saída\n
 * 3 - Entrada de Títulos
 * 4 - Re-Impressão
 */
void RECIBO::carregar_dados(int modo,int tipo)
	{
	char *sql, *aux;
	int i, registros, colunas, natureza,it,limpar, qtd;
	float valor, valores[5], vlr[3];
	string SQL, AUX;
	bool cancelado;
	BANCOMY *protesto;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
	
	limpar = 3;
	if (tipo == 1)
		{
		limpar = 1;
		}
	switch(modo)
		{
		case 1:
			{
			switch(tipo)
				{
				case 1:
					{
					AUX.clear();
					AUX = this->Rec_CliCod->get_text();
					if (AUX.compare("100166") == 0)
						{
						resumo_titulos ();
						}
					if (AUX.length() > 0)
						{
						SQL.clear();
						SQL = "select * from cadastro.clientes where cod_cli="+AUX;
						sql = new char[SQL.length()+1];
						strcpy (sql,SQL.c_str());
						this->conexao->executar(sql);
						delete sql;
						if (this->conexao->query_result == 3)
							{
							cout << this->conexao->mensagem << endl;
							}
						else
							{
							registros = this->conexao->registros;
							colunas = this->conexao->colunas;
							if (registros > 0)
								{
								conexao->resultado();
								linha = conexao->resultados.at(0);
								AUX.clear();
								AUX = linha.at(1);
								this->Rec_Cliente->set_text(Glib::ustring(AUX));
								AUX.clear();
								AUX = linha.at(2);
								this->Rec_End->set_text(Glib::ustring(AUX));
								AUX.clear();
								AUX = linha.at(3);
								this->Rec_Doc->set_text(Glib::ustring(AUX));
								natureza = atoi(linha.at(4).c_str());
								AUX.clear();
								AUX = "Natureza: <b>";
								if (natureza == 1)
									{
									AUX += "Física";
									}
								else 
									{
									AUX += "Jurídica";
									}
								AUX += "</b>";
								this->Rec_Natureza->set_markup(Glib::ustring(AUX));
								if (linha.at(6).compare("t") == 0)
									{
									this->s_issqn = true;
									//cout << "Aqui! verdadeiro" << endl;
									}
								else
									{
									this->s_issqn = false;
									//cout << "Aqui! Falso" << endl;
									}
								this->Recibo->set_focus(*this->Rec_SerCod);
								}
							else
								{
								this->limpar_form_cliente(modo,tipo);
								this->Recibo->set_focus(*this->Rec_CliCod);
								Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Não Encontrado"), false, Gtk::MESSAGE_WARNING);
								dialog.set_secondary_text(Glib::ustring("Este Código de Cliente não encontra-se Cadastrado!"));
								dialog.run();
								}
							}
						}
					else
						{
						this->limpar_form_cliente(modo,tipo);
						this->Recibo->set_focus(*this->Rec_Cliente);
						}
					break;
					}
				case 2:
					{
					AUX.clear();
					AUX = this->Rec_CliCod->get_text();
					if (AUX.length() > 0)
						{
						SQL.clear();
						SQL = "select * from cadastro.clientes where cod_cli="+AUX;
						sql = new char[SQL.length()+1];
						strcpy (sql,SQL.c_str());
						this->conexao->executar(sql);
						delete sql;
						if (this->conexao->query_result == 3)
							{
							cout << this->conexao->mensagem << endl;
							}
						else
							{
							registros = this->conexao->registros;
							colunas = this->conexao->colunas;
							if (registros > 0)
								{
								conexao->resultado();
								linha = conexao->resultados.at(0);
								AUX.clear();
								AUX = linha.at(1);
								this->Rec_Cliente->set_text(Glib::ustring(AUX));
								this->Recibo->set_focus(*this->Rec_SerCod);
								}
							else
								{
								this->limpar_form_cliente(modo,tipo);
								this->Recibo->set_focus(*this->Rec_CliCod);
								Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Não Encontrado"), false, Gtk::MESSAGE_WARNING);
								dialog.set_secondary_text(Glib::ustring("Este Código de Fornecedor não encontra-se Cadastrado!"));
								dialog.run();
								}
							}
						}
					else
						{
						this->limpar_form_cliente(modo,tipo);
						this->Recibo->set_focus(*this->Rec_Cliente);
						}
					break;
					}
				case 4:
					{
					SQL.clear();
					SQL = "select clientes.* from caixa.lancamentos natural join cadastro.clientes where lancamentos.e_s=1 and lancamentos.rec="+this->numero_recibo+" and data='"+this->data_recibo+"'";
					sql = new char[SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					delete sql;
					if (this->conexao->query_result == 3)
						{
						cout << this->conexao->mensagem << endl;
						}
					else
						{
						conexao->resultado();
						linha = conexao->resultados.at(0);
						this->Rec_CliCod->set_text(Glib::ustring(linha.at(0)));
						this->Rec_Cliente->set_text(Glib::ustring(linha.at(1)));
						this->Rec_End->set_text(Glib::ustring(linha.at(2)));
						this->Rec_Doc->set_text(Glib::ustring(linha.at(3)));
						natureza = atoi(linha.at(4).c_str());
						AUX.clear();
						AUX = "Natureza: <b>";
						if (natureza == 1)
							{
							AUX += "Física";
							}
						else 
							{
							AUX += "Jurídica";
							}
						AUX += "</b>";
						if (linha.at(6).compare("t") == 0)
							{
							this->s_issqn = true;
							}
						else
							{
							this->s_issqn = false;
							}
						this->Rec_Natureza->set_markup(Glib::ustring(AUX));
						}
					break;
					}
				}
			break;
			}
		case 2:
			{
			switch(tipo)
				{
				case 1:
				case 2:
				case 3:
					{
					AUX.clear();
					AUX = this->Rec_SerCod->get_text();
					if (AUX.length() > 0)
						{
						aux = new char[4];
						sprintf(aux,"%d",tipo);
						if (tipo == 3)
							{
							strcpy(aux,"1");
							}
						SQL.clear();
						SQL = "select * from cadastro.servicos where e_s=";
						SQL.append(aux);
						SQL += " and codigo="+AUX;
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						delete sql;
						if (this->conexao->query_result == 3)
							{
							cout << this->conexao->mensagem << endl;
							}
						else
							{
							if (this->conexao->registros > 0)
								{
								conexao->resultado();
								linha = conexao->resultados.at(0);
								if ((tipo == 1)||(tipo == 3))
									{
									limpar=1;
									this->cod_servico = atoi(linha.at(0).c_str());
									AUX.clear();
									AUX = linha.at(3);
									this->Rec_Servico->set_text(Glib::ustring(AUX));
									if ((this->cod_servico == 11)||(this->cod_servico == 12))
										{
										protesto = new BANCOMY(CONF_FILE1);
										SQL.clear();
										SQL = "select qtde_tit from pt_ment where data='";
										SQL.append(hoje());
										SQL +="' and tipo=";
										if (this->cod_servico == 11)
											{
											SQL += "1";
											}
										else if (this->cod_servico == 12)
											{
											SQL += "2";
											}
										sql = new char[SQL.length()+1];
										strcpy(sql,SQL.c_str());
										protesto->executar(sql,2);
										delete sql;
										protesto->resultado();
										qtd = atoi(protesto->resultados[0].c_str());
										//cout << qtd << endl;
										SQL = "select ent_tab, ent_tri, pes_tab, pes_tri from tabc001 where data <= '";
										SQL.append (hoje());
										SQL += "' order by data desc";
										sql = new char[SQL.length()+1];
										strcpy(sql,SQL.c_str());
										//cout << sql << endl;
										protesto->executar(sql,2);
										delete sql;
										protesto->resultado();
										//cout << protesto->resultados[0] << endl;
										aux = new char[32];
										strcpy(aux,protesto->resultados[0].c_str());
										//cout << aux << endl;
										valores[0] = char2double(aux);
										delete aux;
										//cout << protesto->resultados[1] << endl;
										aux = new char[32];
										strcpy(aux,protesto->resultados[1].c_str());
										valores[1] = char2double(aux);
										delete aux;
										//cout << protesto->resultados[2] << endl;
										aux = new char[32];
										strcpy(aux,protesto->resultados[2].c_str());
										valores[2] = char2double(aux);
										delete aux;
										//cout << protesto->resultados[3] << endl;
										aux = new char[32];
										strcpy(aux,protesto->resultados[3].c_str());
										valores[3] = char2double(aux);
										delete aux;
										//cout << valores[0] << " " << valores[1] << " " << valores[2]<< " " << valores[3] << endl;
										vlr[0] = valores[0];
										vlr[1] = valores[1];
										valor = valores[1]/2;
										vlr[2] = arredondar(valor);
										valor = valores[2]*(qtd-1);
										vlr[0] += valor;
										valor = valores[3]*(qtd-1);
										vlr[1] += arredondar (valor);
										valor = arredondar (valor)/2;
										vlr[2] += arredondar (valor)-0.01;
										//cout << vlr[0] << " " << vlr[1] << " " << vlr[2] << endl;
										valor = vlr[0]+vlr[1]+vlr[2];
										this->vlrs[0] = vlr[0];
										this->vlrs[1] = vlr[1];
										this->vlrs[2] = vlr[2];
										this->vlrs[3] = valor;
										//cout << valor << endl;
										this->Rec_SerQtd->set_text("1");
										aux = new char[32];
										sprintf (aux,"%0.3f",vlr[0]);
										aux[strlen(aux)-1] = '\0';
										this->Rec_SerVUni->set_text(valor_formatado(aux,2));
										delete aux;
										this->Rec_SerDesc->set_text("0,00");
										aux = new char[32];
										sprintf (aux,"%0.3f",valor);
										aux[strlen(aux)-1] = '\0';
										this->Rec_SerValor->set_text (valor_formatado(aux,2));
										delete aux;
										delete protesto;
										this->Rec_CadServ->set_sensitive (true);
										this->funjecc10 = true;
										this->Recibo->set_focus(*this->Rec_CadServ);
										}
									else
										{
										AUX.clear();
										AUX = linha.at(4);
										it = AUX.find(".");
										if (it != string::npos)
											{
											AUX.replace(it,1,",");
											}
										valor = atof(AUX.c_str());
										AUX.clear();
										aux = new char[10];
										sprintf(aux,"%.2f",valor);
										AUX.append(aux);
										delete aux;
										this->Rec_SerVUni->set_text(Glib::ustring(AUX));
										AUX.clear();
										AUX = linha.at(5);
										this->funjecc10 = false;
										if (AUX.compare("t") == 0)
											{
											this->funjecc10 = true;
											}
										this->Recibo->set_focus(*this->Rec_SerQtd);
										}
									}
								else 
									{
									limpar = 3;
									this->cod_servico = atoi(linha.at(0).c_str());
									AUX.clear();
									AUX = linha.at(3);
									this->Rec_Servico->set_text(Glib::ustring(AUX));
									this->Recibo->set_focus(*this->RecSer_Hist);
									}
								}
							else
								{
								this->limpar_form_servico(limpar);
								this->Recibo->set_focus(*this->Rec_SerCod);
								Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Não Encontrado"), false, Gtk::MESSAGE_WARNING);
								dialog.set_secondary_text(Glib::ustring("Este Código de Serviço não encontra-se Cadastrado!"));
								dialog.run();
								}
							}
						}
					else
						{
						this->limpar_form_servico(limpar);
						this->Recibo->set_focus(*this->Rec_Servico);
						}
					break;
					}
				case 4:
					{
					SQL.clear();
					SQL = "select servicos.cod_serv, servicos.codigo, servicos.descricao, servicos.valor_u, servicos.f10, entrada.qtd, entrada.valor, entrada.desconto, entrada.total, entrada.total_liq, entrada.funjecc10, entrada.issqn from caixa.entrada natural join cadastro.servicos where entrada.e_s=1 and data='"+this->data_recibo+"' and rec="+this->numero_recibo;
					sql = new char [SQL.length()+1];
					strcpy(sql,SQL.c_str());
					this->conexao->executar(sql);
					delete sql;
					if (this->conexao->query_result == 3)
						{
						cout << this->conexao->mensagem << endl;
						}
					else
						{
						registros = this->conexao->registros;
						colunas = this->conexao->colunas;
						this->itens = registros;
						this->vlr_subtotal = this->vlr_total = this->vlr_funjecc = this->vlr_issqn = this->vlr_desc = 0,0;
						//scout << "INICIO FOR" << endl;
						this->dados_serv = Gtk::ListStore::create(this->dados_arv);
						this->Rec_Dados->set_model(this->dados_serv);
						conexao->resultado();
						for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
							{
							linha = *ir;
							this->celula = *(this->dados_serv->append());
							this->celula[dados_arv.cod_servico] = atoi(linha.at(0).c_str());
							this->celula[dados_arv.campo[0]] = linha.at(1);
							this->celula[dados_arv.campo[1]] = linha.at(2);
							this->celula[dados_arv.campo[2]] = linha.at(5);
							AUX.clear();
							AUX = linha.at(6);
							it = AUX.find(".");
							if (it != string::npos)
								{
								AUX.replace(it,1,",");
								}
							valores[0] = atof(AUX.c_str());
							aux = new char[16];
							sprintf(aux,"%0.3f",valores[0]);
							aux[strlen(aux)-1] = '\0';
							this->celula[dados_arv.campo[3]] = aux;
							delete aux;
							AUX.clear();
							AUX = linha.at(7);
							it = AUX.find(".");
							if (it != string::npos)
								{
								AUX.replace(it,1,",");
								}
							valores[1] = atof(AUX.c_str());
							aux = new char[16];
							sprintf(aux,"%0.3f",valores[1]);
							aux[strlen(aux)-1] = '\0';
							this->celula[dados_arv.campo[4]] = aux;
							delete aux;
							this->funjecc10 = false;
							AUX.clear();
							AUX = linha.at(10);
							it = AUX.find(".");
							if (it != string::npos)
								{
								AUX.replace(it,1,",");
								}
							valores[2] = atof(AUX.c_str());
							AUX.clear();
							AUX = linha.at(11);
							it = AUX.find(".");
							if (it != string::npos)
								{
								AUX.replace(it,1,",");
								}
							valores[3] = atof(AUX.c_str());
							if (valores[2] > 0)
								{
								this->funjecc10 = true;
								}
							//cout << valores[2] << "  --  "<< valores[3] << endl;
							aux = new char[16];
							sprintf(aux,"%0.3f",valores[2]);
							aux[strlen(aux)-1] = '\0';
							this->celula[dados_arv.campo[5]] = aux;
							delete aux;
							aux = new char[16];
							sprintf(aux,"%0.3f",valores[3]);
							aux[strlen(aux)-1] = '\0';
							this->celula[dados_arv.campo[6]] = aux;
							delete aux;
							//Valor Subtotal
							this->vlr_subtotal += valores[0];
							//valor Total
							if (this->s_issqn)
								{
								this->vlr_total += ( ( valores[0] + valores[2] ) - valores[1] );
								}
							else
								{
								this->vlr_total += ( ( valores[0] + valores[2] + valores[3] ) - valores[1] );
								}
							//Total Funjecc10
							this->vlr_funjecc += valores[2];
							//Total ISSQN
							this->vlr_issqn += valores[3];
							//total desconto
							this->vlr_desc += valores[1];
							}
						this->Rec_Dados->remove_all_columns();
						this->Rec_Dados->append_column(Glib::ustring("Código"), dados_arv.campo[0]);
						this->Rec_Dados->append_column(Glib::ustring("Serviço"), dados_arv.campo[1]);
						this->Rec_Dados->append_column(Glib::ustring("Quantidade"), dados_arv.campo[2]);
						this->Rec_Dados->append_column(Glib::ustring("Valor"), dados_arv.campo[3]);
						this->Rec_Dados->append_column(Glib::ustring("Desconto"), dados_arv.campo[4]);
						this->Rec_Dados->append_column(Glib::ustring("Funjecc"), dados_arv.campo[5]);
						this->Rec_Dados->append_column(Glib::ustring("ISSQN"), dados_arv.campo[6]);
						for(int i=0; i < 7; i++)
							{
							Gtk::TreeView::Column* coluna_temp = this->Rec_Dados->get_column(i);
							coluna_temp->set_reorderable();	
							}
						//cout << "FINAL FOR" << endl;
						//Setando Sub-Total
						AUX.clear();
						aux = new char[32];
						sprintf (aux,"%0.3f",this->vlr_subtotal);
						aux[strlen(aux)-1] = '\0';
						//cout << aux << " = " << this->vlr_subtotal << endl;
						AUX.append(aux);
						delete aux;
						this->Rec_SubT->set_text(Glib::ustring(AUX));
						//Setando Desconto
						AUX.clear();
						aux = new char[32];
						sprintf (aux,"%0.3f",this->vlr_desc);
						aux[strlen(aux)-1] = '\0';
						AUX.append(aux);
						delete aux;
						this->Rec_Desconto->set_text(Glib::ustring(AUX));
						//Setando Funjecc 10
						AUX.clear();
						aux = new char[32];
						sprintf (aux,"%0.3f",this->vlr_funjecc);
						aux[strlen(aux)-1] = '\0';
						AUX.append(aux);
						delete aux;
						this->Rec_Funjecc->set_text(Glib::ustring(AUX));
						//Setando ISSQN
						AUX.clear();
						aux = new char[32];
						sprintf (aux,"%0.3f",this->vlr_issqn);
						aux[strlen(aux)-1] = '\0';
						AUX.append(aux);
						delete aux;
						this->Rec_ISSQN->set_text(Glib::ustring(AUX));
						//Setando Total
						AUX.clear();
						aux = new char[32];
						sprintf (aux,"%0.3f",this->vlr_total);
						aux[strlen(aux)-1] = '\0';
						AUX.append(aux);
						delete aux;
						this->Rec_Total->set_text(Glib::ustring(AUX));
						}
					break;
					}
				}
			break;
			}
		case 3:
			{
			//dados de protocolos
			this->conexao_pt = new BANCOMY(CONF_FILE1);
			AUX.clear();
			AUX = this->Prot_Numero->get_text();
			this->numero_protocolo.clear();
			this->numero_protocolo = AUX;
			SQL.clear();
			SQL = "select data, protocolo, status, portador, endereco, v_cartorio, v_protesto, v_intima, v_edital, v_funadep, v_correio from pt_mov where data='"+this->data_protocolo+"' and protocolo="+this->numero_protocolo;
			//cout << SQL << endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao_pt->executar(sql,2);
			delete sql;
			if (this->conexao_pt->query_result == 3)
				{
				cout << this->conexao_pt->mensagem << endl;
				}
			else
				{
				registros = this->conexao_pt->registros;
				if (registros == 1)
					{
					this->conexao_pt->resultado();
					this->Rec_Cliente->set_text(Glib::ustring(this->conexao_pt->resultados[3]));
					this->Rec_End->set_text(Glib::ustring(this->conexao_pt->resultados[4]));
					this->checar_clienteE(3);
					//AR
					if ((this->conexao_pt->resultados[2].compare("AR") == 0)||(this->conexao_pt->resultados[2].compare("PROTESTADO") == 0))
						{
						//cout << "Apontamento: " << this->conexao_pt->resultados[5] << endl;
						AUX.clear();
						AUX = this->conexao_pt->resultados[5];
						it = AUX.find(".");
						if (it!=string::npos)
							{
							AUX.replace(it,1,",");
							}
						this->incluir_servicos(12,AUX);
						//cout << "Protesto: " << this->conexao_pt->resultados[6] << endl;
						AUX.clear();
						AUX = this->conexao_pt->resultados[6];
						it = AUX.find(".");
						if (it!=string::npos)
							{
							AUX.replace(it,1,",");
							}
						this->incluir_servicos(13,AUX);
						//cout << "Intimação: " << this->conexao_pt->resultados[7] << endl;
						AUX.clear();
						AUX = this->conexao_pt->resultados[7];
						it = AUX.find(".");
						if (it!=string::npos)
							{
							AUX.replace(it,1,",");
							}
						this->incluir_servicos(53,AUX);
						//cout << "Edital: " << this->conexao_pt->resultados[8] << endl;
						aux = new char[70];
						strcpy(aux,"select valor_u from cadastro.servicos where e_s=1 and codigo=54");
						this->conexao->executar(aux);
						delete aux;
						if (this->conexao->query_result == 3)
							{
							cout << this->conexao->mensagem << endl;
							}
						else
							{
							AUX.clear();
							AUX = this->conexao->resultado(0,0);
							it = AUX.find(".");
							if (it!=string::npos)
								{
								AUX.replace(it,1,",");
								}
							this->incluir_servicos(54,AUX);
							}
						//cout << "Funadep: " << this->conexao_pt->resultados[9] << endl;
						if (this->conexao_pt->resultados[9].compare ("0.00") != 0)
							{
							AUX.clear();
							AUX = this->conexao_pt->resultados[9];
							it = AUX.find(".");
							if (it!=string::npos)
								{
								AUX.replace(it,1,",");
								}
							this->incluir_servicos(32,AUX);
							}
						//cout << "Correio: " << this->conexao_pt->resultados[10] << endl;
						if (this->conexao_pt->resultados[10].compare ("0.00") != 0)
							{
							AUX.clear();
							AUX = this->conexao_pt->resultados[10];
							it = AUX.find(".");
							if (it!=string::npos)
								{
								AUX.replace(it,1,",");
								}
							this->incluir_servicos(60,AUX);
							}
						}
					}
				}
			delete this->conexao_pt;
			this->Recibo->set_focus(*this->Rec_GERAR);
			break;
			}
		case 4:
			{
			SQL.clear();
			SQL = "select lancamentos.status, lancamentos.data_qt, funcionario.u_login, lancamentos.tipo, lancamentos.obs from caixa.lancamentos inner join cadastro.funcionario on lancamentos.cod_fun=funcionario.cod_fun where e_s=1 and data='"+this->data_recibo+"' and rec="+this->numero_recibo;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				conexao->resultado();
				linha = conexao->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				if (AUX.compare ("t") == 0)
					{
					cancelado = false;
					this->Rec_Status->set_text("");
					}
				else
					{
					cancelado = true;
					this->Rec_Status->set_markup("<span foreground='red' size='large' font_weight='bold'>CANCELADO</span>");
					this->Rec_GERAR->set_sensitive (false);
					this->Rec_CancelServ->set_sensitive (false);
					}
				AUX.clear();
				AUX = linha.at(1);
				if (AUX.length() > 0)
					{
					aux = new char[15];
					strcpy(aux,AUX.c_str());
					aux = data_formatada(aux,2);
					AUX.clear();
					AUX += "Data Pagamento: <b>";
					AUX.append(aux);
					AUX += "</b>";
					delete aux;
					this->Rec_INFO[0]->set_markup (AUX);
					}
				else
					{
					this->Rec_INFO[0]->set_text ("\t\t");
					}
				AUX.clear();
				AUX = "Funcionário: <b>";
				AUX = linha.at(2);
				AUX += "</b> \t<span foreground='red' font_weight='bold'>";
				if (linha.at(3).compare("D") == 0)
					{
					AUX += "Débito";
					if (!cancelado)
						{
						if ((this->caixa)||(this->n_acesso ==0))
							{
							this->Rec_BDebCred->set_sensitive (true);
							}
						}
					}
				else
					{
					AUX += "Crédito";
					}
				AUX += "</span>";
				this->Rec_INFO[1]->set_markup (Glib::ustring(AUX));
				AUX.clear();
				AUX = linha.at(4);
				this->Rec_OBS->set_text(Glib::ustring(AUX));
				}
			break;
			}
		}
	}

/**
 * Conforme o recibo que está sendo gerado determinadas entrys são carregadas, por isso os parâmetros
 * passados nesse metódo devem ser bem direcionados.
 * \param modo é utilizado para identicar se o recibo é de entrada ou saída. Portando pode assumir os valores: \n
 * 1 - Entrada\n
 * 2 - Saída\n
 * \param tipo é utilizado para limitar o preenchimento.
 * 1 - Preenchimento total
 * 2 - Preenchimento parcial
 */
void RECIBO::limpar_form_cliente(int modo, int tipo)
	{
	switch (modo)
		{
		case 1:
			{
			switch(tipo)
				{
				case 1:
					{
					this->Rec_Cliente->set_text("");
					this->Rec_End->set_text("");
					this->Rec_Doc->set_text("");
					this->Rec_Natureza->set_markup(Glib::ustring("Natureza:"));
					break;
					}
				case 2:
					{
					this->Rec_Cliente->set_text("");
					break;
					}
				}
			break;
			}
		case 2:
			{
			switch(tipo)
				{
				case 1:
					{
					this->Rec_CliCod->set_text("");
					this->Rec_End->set_text("");
					this->Rec_Doc->set_text("");
					this->Rec_Natureza->set_markup(Glib::ustring("Natureza:"));
					}
				case 2:
					{
					this->Rec_CliCod->set_text("");
					break;
					}
				}
			break;
			}
		}
	}

/**
 * Conforme o valor passado no parâmetro ele irá limpar as entrys de cadastro de serviços.
 * \param tipo é usado para direcionar no cadastramento do serviço:\n
 * 1 - Serviço de Entrada pelo Código\n
 * 2 - Serviço de Entrada pela Descrição\n
 * 3 - Serviço de Saída
 */
void RECIBO::limpar_form_servico(int tipo)
	{
	//cout << tipo << endl;
	switch(tipo)
		{
		case 1:
			{
			this->Rec_Servico->set_text("");
			this->Rec_SerQtd->set_text("");
			this->Rec_SerValor->set_text("");
			this->Rec_SerDesc->set_text("");
			this->Rec_SerVUni->set_text("");
			break;
			}
		case 2:
			{
			this->Rec_SerCod->set_text("");
			this->Rec_Servico->set_text("");
			this->Rec_SerQtd->set_text("");
			this->Rec_SerValor->set_text("");
			this->Rec_SerDesc->set_text("");
			this->Rec_SerVUni->set_text("");
			break;
			}
		case 3:
			{
			this->Rec_SerCod->set_text("");
			this->Rec_Servico->set_text("");
			break;
			}
		}
	}

/**
 * Conforme a tela do Recibo é utilizado determinadas EntryCompletions e ComboBoxTexts.
 * \param tipo utilizado para carregar os dados nos determinados campos:\n
 * 1 - Cadastro de Clientes (EntryCompletion)\n
 * 2 - Cadastro de Serviços (EntryCompletion)\n
 * 3 - Histórico Complementar (EntryCompletion)\n
 * 4 - Últimas 15 datas de protocolos apontados (ComboBoxText - Dados externos)\n
 * 5 - Protocolos de determinada data selecionada (ComboBoxText - Dados externos)\n
 * 6 - Datas de Recibos.\n
 * 7 - Número de Recibos de uma determinada Data.\n
 * \param e_s utilizado para identificar quando o parâmetro tipo for 2 se os serviços são de entrada ou de saída.
 */
void RECIBO::preparar_dados(int tipo,int e_s)
	{
	char *sql, *aux, *data_ot;
	int i, total, it;
	string SQL, AUX;
	vector<vector<string> >::iterator ir;
	vector<string> linha;
		
	switch(tipo)
		{
		case 1:
			{
			SQL.clear();
			SQL = "select cod_cli,nome from cadastro.clientes order by nome";
			sql = new char[SQL.length()+1];
			strcpy (sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->dados_ref->append());
						celula[dados_arv.cod_cli] = atoi(linha.at(0).c_str());
						celula[dados_arv.descricao] = linha.at(1);
						}
					}
				else
					{
					celula = *(this->dados_ref->append());
					celula[dados_arv.cod_cli] = 0;
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryCliente->set_text_column(dados_arv.descricao);
			break;
			}
		case 2:
			{
			aux = new char[5];
			sprintf(aux,"%d",e_s);
			if (e_s == 3)
				{
				strcpy(aux,"1");
				}
			SQL.clear();
			SQL = "select cod_serv, descricao from cadastro.servicos where e_s=";
			SQL.append(aux);
			delete aux;
			SQL += " order by descricao";
			sql = new char[SQL.length()+1];
			strcpy (sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->dados_ref->append());
						celula[dados_arv.cod_servico] = atoi(linha.at(0).c_str());
						celula[dados_arv.descricao] = linha.at(1);
						}
					}
				else
					{
					celula = *(this->dados_ref->append());
					celula[dados_arv.cod_servico] = 0;
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryServico->set_text_column(dados_arv.descricao);
			break;
			}
		case 3:
			{
			SQL.clear();
			SQL = "select historico_complementar from caixa.saida group by historico_complementar order by historico_complementar ";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			celula = *(this->dados_historico->append());
			celula[dados_arv.descricao] = "CHEQUE";
			celula = *(this->dados_historico->append());
			celula[dados_arv.descricao] = "DINHEIRO";
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->dados_historico->append());
						celula[dados_arv.descricao] = linha.at(0);
						}
					}
				else
					{
					celula = *(this->dados_historico->append());
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryHistorico->set_text_column(dados_arv.descricao);
			break;
			}
		case 4:
			{
			this->conexao_pt = new BANCOMY(CONF_FILE1);
			data_ot = new char[14];
			data_ot = data_otima(7);
			SQL.clear();
			SQL = "select data from pt_mov where data >= '";
			SQL.append(data_ot);
			delete data_ot;
			SQL += "' group by data order by data desc";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			this->conexao_pt->executar(sql,2);
			delete sql;
			if (this->conexao_pt->query_result == 3)
				{
				cout << this->conexao_pt->mensagem << endl;
				}
			else
				{
				total = this->conexao_pt->registros;
				if (total > 0)
					{
					for (i=0; i < total; i++)
						{
						this->conexao_pt->resultado();
						aux = new char[12];
						strcpy(aux,this->conexao_pt->resultados[0].c_str());
						//cout << aux << endl;
						celula = *(this->dados_protdata->append());
						celula[dados_arv.descricao] = data_formatada(aux,2);
						}
					}
				else
					{
					celula = *(this->dados_protdata->append());
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryProtData->set_text_column(dados_arv.descricao);
			delete this->conexao_pt;
			break;
			}
		case 5:
			{
			this->Recibo->set_focus(*this->Prot_Numero);
			this->conexao_pt = new BANCOMY(CONF_FILE1);
			AUX.clear();
			AUX = this->Prot_Data->get_text();
			data_ot = new char[AUX.length()+1];
			strcpy(data_ot,AUX.c_str());
			data_ot = data_formatada(data_ot,1);
			this->data_protocolo.clear();
			this->data_protocolo.append(data_ot);
			SQL.clear();
			SQL = "select PROTOCOLO from pt_mov where DATA='";
			SQL.append(data_ot);
			delete data_ot;
			SQL += "' group by PROTOCOLO order by PROTOCOLO desc";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao_pt->executar(sql,2);
			delete sql;
			if (this->conexao_pt->query_result == 3)
				{
				cout << this->conexao_pt->mensagem << endl;
				}
			else
				{
				total = this->conexao_pt->registros;
				for (i=0; i < total; i++)
					{
					this->conexao_pt->resultado();
					celula = *(this->dados_protnum->append());
					celula[dados_arv.descricao]=this->conexao_pt->resultados[0];
					}
				}
			this->EntryProtNum->set_text_column(dados_arv.descricao);
			delete this->conexao_pt;
			break;
			}
		case 6:
			{
			SQL.clear();
			SQL = "select data from caixa.lancamentos where e_s=1 group by data order by data desc";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->dados_datas->append());
						aux = new char[12];
						strcpy(aux,linha.at(0).c_str());
						celula[dados_arv.descricao] = data_formatada(aux,2);
						delete aux;
						}
					}
				else
					{
					celula = *(this->dados_datas->append());
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryData->set_text_column(dados_arv.descricao);
			break;
			}
		case 7:
			{
			this->EntryNumeros = Gtk::EntryCompletion::create();
			this->SelNumero->set_completion(this->EntryNumeros);
			this->dados_numeros = Gtk::ListStore::create(this->dados_arv);
			this->EntryNumeros->set_model(this->dados_numeros);
			SQL.clear();
			SQL = "select rec from caixa.lancamentos where e_s=1 and data='";
			AUX.clear();
			AUX = this->SelData->get_text();
			aux = new char[12];
			strcpy(aux,AUX.c_str());
			SQL.append(data_formatada(aux,1));
			delete aux;
			SQL+="' order by rec desc";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				total = this->conexao->registros;
				if (total > 0)
					{
					conexao->resultado();
					for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
						{
						linha = *ir;
						celula = *(this->dados_numeros->append());
						celula[dados_arv.descricao] = linha.at(0);
						}
					}
				else
					{
					celula = *(this->dados_numeros->append());
					celula[dados_arv.descricao] = "Não há registros na base de dados";
					}
				}
			this->EntryNumeros->set_text_column(dados_arv.descricao);
			break;
			}
		}
	}

/**
 * Conforme a tela do Recibo (Entrada/Saída) é checado a existência do cliente conforme os dados inseridos
 * \param e_s refere-se à tela do recibo que está sendo gerado.\n
 * 1 - Entrada\n
 * 2 - Saída\n
 * 3 - Entrada de Título\n
 */
void RECIBO::checar_clienteE(int e_s)
	{
	char *sql;
	int natureza;
	string SQL, AUX;
	vector<string> linha;
		
	SQL.clear();
	SQL = this->Rec_Cliente->get_text();
	SQL = "select * from cadastro.clientes where nome='"+SQL+"'";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (this->conexao->registros > 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			if (e_s == 1)
				{
				AUX.clear();
				AUX = linha.at(0);
				this->Rec_CliCod->set_text(Glib::ustring(AUX));
				AUX.clear();
				AUX = linha.at(2);
				this->Rec_End->set_text(Glib::ustring(AUX));
				AUX.clear();
				AUX = linha.at(3);
				this->Rec_Doc->set_text(Glib::ustring(AUX));
				natureza = atoi(linha.at(4).c_str());
				AUX.clear();
				AUX = "Natureza: <b>";
				if (natureza == 1)
					{
					AUX += "Física";
					}
				else 
					{
					AUX += "Jurídica";
					}
				AUX += "</b>";
				this->Rec_Natureza->set_markup(Glib::ustring(AUX));
				this->Rec_End->set_editable(false);
				this->Rec_Doc->set_editable(false);
				this->Recibo->set_focus(*this->Rec_SerCod);
				}
			else if(e_s == 2)
				{
				AUX.clear();
				AUX = linha.at(0);
				this->Rec_CliCod->set_text(Glib::ustring(AUX));
				this->Recibo->set_focus(*this->Rec_SerCod);
				}
			else
				{
				AUX.clear();
				AUX = linha.at(0);
				this->Rec_CliCod->set_text(Glib::ustring(AUX));
				this->update_apresentante(AUX);
				}
			}
		else
			{
			if (e_s != 3)
				{
				this->limpar_form_cliente(2,e_s);
				if (e_s == 1)
					{
					this->Rec_End->set_editable(true);
					this->Rec_Doc->set_editable(true);
					this->Recibo->set_focus(*this->Rec_End);
					}
				else
					{
					//Cadastro de novo Fornecedor
					this->novo_cliente (e_s);
					}
				}
			else
				{
				//Cadastro de novo Apresentante
				this->novo_cliente (e_s);
				}
			}
		}
	}

/**
 * A checagem do serviço ocorrer em duas situações: Entrada e Saída
 * \param modo assume os valores de 1 e 2:\n
 * 1 - Entrada\n
 * 2 - Saída\n
 */
void RECIBO::checar_servicoE(int modo)
	{
	char *sql, *aux;
	int it, limpar;
	float valor;
	string SQL, AUX;
	vector<string> linha;

	limpar = 3;
	if (modo == 1)
		{
		limpar = 1;
		}
	AUX.clear();
	AUX = this->Rec_Servico->get_text();
	aux = new char[4];
	sprintf(aux,"%d",modo);
	SQL.clear();
	SQL = "select * from cadastro.servicos where e_s=";
	SQL.append(aux);
	delete aux;
	SQL +=" and descricao='"+AUX+"'";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (this->conexao->registros > 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			if (modo == 1)
				{
				this->cod_servico = atoi(linha.at(0).c_str());
				AUX.clear();
				AUX = linha.at(2);
				this->Rec_SerCod->set_text(Glib::ustring(AUX));
				AUX = linha.at(4);
				it = AUX.find(".");
				if (it != string::npos)
					{
					AUX.replace(it,1,",");
					}				
				valor = atof(AUX.c_str());
				AUX.clear();
				aux = new char[10];
				sprintf(aux,"%.2f",valor);
				AUX.append(aux);
				delete aux;
				this->Rec_SerVUni->set_text(Glib::ustring(AUX));
				AUX.clear();
				AUX = linha.at(5);
				this->funjecc10 = false;
				if (AUX.compare("t") == 0)
					{
					this->funjecc10 = true;
					}
				this->Recibo->set_focus(*this->Rec_SerQtd);
				}
			else
				{
				this->cod_servico = atoi(linha.at(0).c_str());
				AUX.clear();
				AUX = linha.at(2);
				this->Rec_SerCod->set_text(Glib::ustring(AUX));
				this->Recibo->set_focus(*this->RecSer_Hist);
				}
			}
		else
			{
			this->limpar_form_servico(limpar);
			this->Recibo->set_focus(*this->Rec_Servico);
			Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Não Encontrado"), false, Gtk::MESSAGE_ERROR);
			dialog.set_secondary_text(Glib::ustring("Este Serviço não encontra-se Cadastrado!"));
			dialog.run();
			}
		}
	}

/**
 * Após checada a não existência do cliente no sistema utilizamos esse método para cadastrar
 * o novo cliente.
 * \param e_s utilizado para orientar o método de qual cliente será cadastrado.\n
 * 1 - Entrada\n
 * 2 - Saída\n
 * 3 - Entrada Título\n
 */
void RECIBO::novo_cliente(int e_s)
	{
	char *doc, *sql, *aux;
	int natureza, it;
	bool verificado;
	string documento, nat, nat_int, SQL, AUX;
	vector<string> linha;

	switch(e_s)
		{
		case 1:
			{
			documento.clear();
			documento = this->Rec_Doc->get_text();
			doc = new char[documento.length()+1];
			strcpy(doc,documento.c_str());
			if (documento.length() == 11)
				{
				natureza = 1;
				nat.clear();
				nat = "Física";
				nat_int.clear();
				nat_int = "1";
				}
			else 
				{
				natureza = 2;
				nat.clear();
				nat = "Jurídica";
				nat_int.clear();
				nat_int = "2";
				}
			if (!checar_doc(doc,natureza))
				{
				Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Checagem de Documento"), false, Gtk::MESSAGE_ERROR);
				dialog.set_message(Glib::ustring("Documento inválido! Verifique!"));
				dialog.run();
				this->Recibo->set_focus(*this->Rec_Doc);
				}
			else
				{
				AUX.clear();
				AUX = "Natureza: <b>" + nat + "</b>";
				this->Rec_Natureza->set_markup(Glib::ustring(AUX));
				SQL.clear();
				SQL = "insert into cadastro.clientes (cod_cli,nome, endereco, documento, tipo_doc) values(nextval('cadastro.clientes_nov_inc'),'";
				AUX.clear();
				AUX = this->Rec_Cliente->get_text();
				SQL += AUX + "','";
				AUX.clear();
				AUX = this->Rec_End->get_text();
				SQL += AUX + "','" + documento + "'," + nat_int + ") returning cod_cli";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				this->conexao->executar(sql);
				if (this->conexao->query_result == 3)
					{
					cout << this->conexao->mensagem << endl;
					}
				else
					{
					conexao->resultado();
					linha = conexao->resultados.at(0);
					AUX.clear();
					AUX = linha.at(0);
					this->Rec_CliCod->set_text(Glib::ustring(AUX));
					this->Rec_End->set_editable(false);
					this->Rec_Doc->set_editable(false);
					this->Recibo->set_focus(*this->Rec_SerCod);
					Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Cadastramento"), false, Gtk::MESSAGE_INFO);
					dialog.set_message(Glib::ustring("Cliente Cadastrado com sucesso!"));
					dialog.run();
					}
				}
			break;
			}
		case 2:
			{
			SQL.clear();
			SQL = "insert into cadastro.clientes (cod_cli,nome,  tipo_doc) values(nextval('cadastro.clientes_nov_inc'),'";
			AUX.clear();
			AUX = this->Rec_Cliente->get_text();
			SQL += AUX + "',0) returning cod_cli";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				conexao->resultado();
				linha = conexao->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				this->Rec_CliCod->set_text(Glib::ustring(AUX));
				}
			break;
			}
		case 3:
			{
			SQL.clear();
			SQL = "insert into cadastro.clientes (cod_cli,nome, endereco, tipo_doc) values(nextval('cadastro.clientes_nov_inc'),'";
			AUX.clear();
			AUX = this->Rec_Cliente->get_text();
			SQL += AUX + "','";			AUX.clear();
			AUX = this->Rec_End->get_text();
			SQL += AUX + "',0) returning cod_cli";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				conexao->resultado();
				linha = conexao->resultados.at(0);
				AUX.clear();
				AUX = linha.at(0);
				this->Rec_CliCod->set_text(Glib::ustring(AUX));
				}
			break;
			}
		}
	}

/**
 * Este método é reponsável tanto pelo cálculo na inclusão quanto na alteração das
 * informações sobre o serviço digitado.
 * \param etapa é usado para identificar se o serviço é de entrada ou saída.\n
 * 1 - Entrada\n
 * 2 - Saída\n
 */
void RECIBO::calcular_valor(int etapa)
	{
	char *aux,*sql;
	int i, qtd,it;
	float valor_u, valor, desc, funjecc, issqn;
	bool divisao;
	string AUX, SQL;
	vector<string> linha;

	ato_gratuito = false;
	if (Ato_Gratuito->get_active())
		{
		ato_gratuito = true;
		}

	divisao = false;
	SQL.clear();
	SQL = "select valor_u from cadastro.servicos where cod_serv=";
	aux = new char[15];
	sprintf(aux,"%d",this->cod_servico);
	SQL.append(aux);
	delete aux;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result != 3)
		{
		conexao->resultado();
		linha = conexao->resultados.at(0);
		//cout << this->conexao->resultado(0,0) << endl;
		if (linha.at(0).compare("0") == 0)
			{
			divisao = true;
			}
		}
	switch(etapa)
		{
		case 1:
			{
			AUX.clear();
			AUX = this->Rec_SerVUni->get_text();
			valor_u = atof(AUX.c_str());
			if (ato_gratuito)
				{
				valor_u = 0;
				}
			//valor_u = char2double(AUX.c_str());
			AUX.clear();
			AUX = this->Rec_SerQtd->get_text();
			qtd = atoi(AUX.c_str());
			if (divisao && (qtd > 1))
				{
				valor = valor_u;
				valor_u = valor / (float) qtd;
				aux = new char[15];
				sprintf(aux,"%f",valor_u);
				this->Rec_SerVUni->set_text(aux);
				delete aux;
				}
			else
				{
				valor = qtd * valor_u;
				}
			if (this->funjecc10)
				{
				funjecc = valor/10,0;
				funjecc = this->arredondar (funjecc);
				issqn =  valor/20,0;
				issqn = this->arredondar (issqn);
				valor += funjecc + issqn;
				}
			aux = new char[10];
			sprintf(aux,"%.2f",valor);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->Rec_SerValor->set_text(Glib::ustring(AUX));
			if (this->alterado)
				{
				this->Recibo->set_focus(*this->Rec_AltServ);
				}
			else
				{
				this->Rec_CadServ->set_sensitive(true);
				this->Recibo->set_focus(*this->Rec_CadServ);
				}
			//this->Recibo->set_focus(*this->Rec_SerDesc);
			break;
			}
		case 2:
			{
			AUX.clear();
			AUX = this->Rec_SerValor->get_text();
			valor = atof(AUX.c_str());
			if (ato_gratuito)
				{
				valor = 0;
				}
			//valor = char2double(AUX.c_str());
			AUX.clear();
			AUX = this->Rec_SerDesc->get_text();
			desc = 0,0;
			if (AUX.length() > 0)
				{
				desc = atof(AUX.c_str());
				//desc = char2double(AUX.c_str());
				}
			valor = valor - desc;
			aux = new char[10];
			sprintf(aux,"%.2f",desc);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->Rec_SerDesc->set_text(AUX);
			aux = new char[10];
			sprintf(aux,"%.2f",valor);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->Rec_SerValor->set_text(Glib::ustring(AUX));
			if (this->alterado)
				{
				this->Recibo->set_focus(*this->Rec_AltServ);
				}
			else
				{
				this->Rec_CadServ->set_sensitive(true);
				this->Recibo->set_focus(*this->Rec_CadServ);
				}
			break;
			}
		}
	}

/**
 * Inclui o serviço digitado na TreeViewColumn referente.
 */
void RECIBO::incluir_servico()
	{
	char *aux;
	int quantidade;
	float valor_u, desc, valor, funjecc10, issqn;
	string AUX;

	ato_gratuito = false;
	if (Ato_Gratuito->get_active())
		{
		ato_gratuito = true;
		}
	if (!this->alterado)
		{
		this->itens++;
		}
	if(!this->alterado)
		{
		this->celula = *(this->dados_serv->append());
		}
	else
		{
		this->celula = this->reg_selecionado;
		}
	cout << cod_servico << endl;
	this->celula[dados_arv.cod_servico] = this->cod_servico;
	AUX.clear();
	AUX = this->Rec_SerCod->get_text();
	this->celula[dados_arv.campo[0]] = Glib::ustring(AUX);
	AUX.clear();
	AUX = this->Rec_Servico->get_text(); 
	this->celula[dados_arv.campo[1]] = Glib::ustring(AUX);
	AUX.clear();
	AUX = this->Rec_SerQtd->get_text();
	this->celula[dados_arv.campo[2]] = Glib::ustring(AUX);
	quantidade = atoi(AUX.c_str());
	AUX.clear();
	AUX = this->Rec_SerVUni->get_text();
	valor_u = atof(AUX.c_str());
	if (ato_gratuito)
		{
		valor_u = 0;
		}
	//valor_u = char2double(AUX.c_str());
	//this->celula[dados_arv.valor_u] = valor_u;
	valor = valor_u * (float) quantidade;
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",valor);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->celula[dados_arv.campo[3]] = Glib::ustring(AUX);
	AUX.clear();
	AUX = this->Rec_SerDesc->get_text();
	if (AUX.length() > 0)
		{
		this->celula[dados_arv.campo[4]] = Glib::ustring(AUX);
		desc = atof(AUX.c_str());
		//desc = char2double(AUX.c_str());
		}
	else
		{
		this->celula[dados_arv.campo[4]] = Glib::ustring("0,0");
		desc = 0,0;
		}
	if (this->alterado)
		{
		this->vlr_desc -= servicos.desconto;
		}
	//cout << valor << endl;
	if (this->funjecc10)
		{
		if ((this->cod_servico == 11)||(this->cod_servico == 12))
			{
			funjecc10 = this->vlrs[1];
			issqn = this->vlrs[2];
			}
		else
			{
			funjecc10 = valor/10,0;
			funjecc10 = this->arredondar (funjecc10);
			issqn = valor/20,0;
			issqn = this->arredondar(issqn);
			}
		}
	else
		{
		funjecc10 = 0,0;
		issqn = 0,0;
		}
	//cout << funjecc10 << " - " << issqn << endl;
	aux = new char[50];
	sprintf(aux, "%.2f",funjecc10);
	AUX.clear();
	AUX.append(aux);
	delete aux;
	this->celula[dados_arv.campo[5]]= Glib::ustring(AUX);
	aux = new char[50];
	sprintf(aux, "%.2f",issqn);
	AUX.clear();
	AUX.append(aux);
	delete aux;
	this->celula[dados_arv.campo[6]]= Glib::ustring(AUX);
	//cout << "Valor" << this->vlr_total << endl;
	if (this->alterado)
		{
		float old_vlr=0.0, old_fj10=0.0, old_issqn=0.0, old_desc=0.0;
		old_vlr = (float)servicos.quantidade*servicos.valor_u;
		//cout << "OLD: " << old_vlr << endl;
		old_desc = servicos.desconto;
		//cout << "DESC: " << old_desc << endl;
		this->vlr_subtotal -= old_vlr;
		if (this->funjecc10)
			{
			old_fj10 = (old_vlr*10)/100;
			this->vlr_funjecc -= old_fj10;
			old_issqn = (old_vlr*5)/100;
			this->vlr_issqn -= old_issqn;
			if (this->s_issqn)
				{
				old_vlr+=old_fj10;
				}
			else
				{
				old_vlr+=old_fj10+old_issqn;
				}
			}
		//cout << "OLD: " << old_vlr << endl;
		//cout << "OLD: " << old_fj10 << endl;
		//cout << "OLD: " << old_issqn << endl;
		old_vlr -= servicos.desconto;
		this->vlr_total -= old_vlr;
		}
	//Valor Subtotal
	this->vlr_subtotal += valor;
	//valor Total
	//cout << "Valor" << this->vlr_total << endl;
	//cout << valor << " - " << funjecc10 << " - " << issqn << " - " << desc << endl;
	if (this->s_issqn)
		{
		this->vlr_total += ( ( valor + funjecc10 ) - desc );
		}
	else
		{
		this->vlr_total += ( ( valor + funjecc10 + issqn ) - desc );
		}
	//Total Funjecc10
	this->vlr_funjecc += funjecc10;
	//Total ISSQN
	this->vlr_issqn += issqn;
	//total desconto
	this->vlr_desc += desc;
	//Setando Sub-Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_subtotal);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_SubT->set_text(Glib::ustring(AUX));
	//Setando Desconto
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_desc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Desconto->set_text(Glib::ustring(AUX));
	//Setando Funjecc 10
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_funjecc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Funjecc->set_text(Glib::ustring(AUX));
	//Setando ISSQN
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_issqn);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_ISSQN->set_text(Glib::ustring(AUX));
	//Setando Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_total);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Total->set_text(Glib::ustring(AUX));
	this->limpar_form_servico(2);
	this->Rec_CadServ->set_sensitive(false);
	this->Recibo->set_focus(*this->Rec_SerCod);
	this->alterado = false;
	}

/**
 * \param path caminho da TreeModel selecionada.
 * \param column coluna selecionada do serviço.
 */
void RECIBO::selecionar_servico(const Gtk::TreeModel::Path& path,Gtk::TreeViewColumn* column)
	{
	Gtk::TreeModel::iterator contador;
	//Gtk::TreeModel::Row registro;
	int cod;
	float fjc10, valor, issqn;
	Glib::ustring AUX;

	contador =  this->dados_serv->get_iter(path);
	if (contador)
		{
		this->reg_selecionado = *contador;
		if (reg_selecionado)
			{
			servicos.codigo=reg_selecionado[dados_arv.cod_servico];
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[0]];
			servicos.cod_id=AUX;
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[1]];
			servicos.descricao=AUX;
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[2]];
			servicos.quantidade=atoi(AUX.c_str());
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[3]];
			valor = atof(AUX.c_str());
			//valor = char2double(AUX.c_str());
			servicos.valor = valor;
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[5]];
			fjc10 = atof(AUX.c_str());
			//fjc10 = char2double(AUX.c_str());
			if (fjc10 > 0.0)
				{
				servicos.fj10 = true;
				}
			else
				{
				servicos.fj10 = false;
				}
			this->funjecc10 = servicos.fj10;
			AUX.clear();
			AUX=reg_selecionado[dados_arv.campo[4]];
			servicos.desconto = atof(AUX.c_str());
			servicos.valor_u = servicos.valor/servicos.quantidade;
			/*cout << servicos.codigo << " - ";
			cout << servicos.cod_id << " - ";
			cout << servicos.descricao << " - ";
			cout << servicos.quantidade << " - ";
			cout << servicos.valor_u << " - ";
			cout << servicos.valor << " - ";
			cout << servicos.fj10 << " - ";
			cout << servicos.desconto << endl;*/
			}
		}
	this->carregar_servico_sel();
	}

/**
 * Carrega um determinado serviço selecionada em uma TreeViewColumn para o formulário de alteração/remoção.
 */
void RECIBO::carregar_servico_sel()
	{
	string AUX;
	char *aux;

	this->alterado = true;
	this->Rec_CadServ->set_sensitive (false);
	this->Rec_DelServ->set_sensitive (true);
	this->Rec_AltServ->set_sensitive (true);
	this->cod_servico = servicos.codigo;
	this->Rec_SerCod->set_text(servicos.cod_id);
	this->Rec_Servico->set_text(servicos.descricao);
	aux = new char[32];
	sprintf(aux,"%d",servicos.quantidade);
	AUX.clear();
	AUX.append(aux);
	delete aux;
	this->Rec_SerQtd->set_text(AUX);
	aux = new char[15];
	sprintf(aux,"%0.3f",servicos.valor_u);
	aux[strlen(aux)-1] = '\0';
	AUX.clear();
	AUX.append(aux);
	delete aux;
	this->Rec_SerVUni->set_text(AUX);
	aux = new char[15];
	sprintf(aux,"%0.3f",servicos.desconto);
	aux[strlen(aux)-1] = '\0';
	AUX.clear();
	AUX.append(aux);
	delete aux;
	this->Rec_SerDesc->set_text(AUX);
	this->funjecc10 = servicos.fj10;
	this->Recibo->set_focus(*this->Rec_SerQtd);
	this->calcular_valor (1);
	}

/**
 * É checado os campos necessários para geração de número de recibo
 * \param tipo é a identificação do tipo de recibo que está sendo emitido\n
 * 1 - Entrada\n
 * 2 - Saída\n
 * 3 - Entrada Títulos\n
 */
void RECIBO::checar_campos (int tipo)
	{
	bool checar;
	Gtk::TreeModel::Row registro;
	type_children::iterator i;
	int j;
	Glib::ustring AUX;

	checar = true;
	//campo do cliente
	if (Rec_CliCod->get_text_length () == 0)
		{
		checar = false;
		}
	else
		{
		type_children children = dados_serv->children();
		j = 0;
		for(i = children.begin(); i != children.end(); ++i)
			{
			registro = *i;
			if(registro)
				{
				j++;
				cout << registro[dados_arv.cod_servico] << endl;
				if (registro[dados_arv.cod_servico] < 0)
					{
					checar = false;
					break;
					}
				else 
					{
					AUX.clear();
					AUX = registro[dados_arv.campo[2]];
					cout << AUX << endl;
					if (AUX.compare("") == 0)
						{
						checar = false;
						break;
						}
					}	
				}
			}
		if (j == 0)
			{
			checar = false;
			}
		cout << checar << endl;
		//checar = true;
		}
	if (checar)
		{
		Funcionario (tipo);
		}
	else
		{
		Gtk::MessageDialog dialog(*Recibo, Glib::ustring("Falha no Preenchimento"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring("Verifique o código do Cliente e as quantidades de serviços"));
		dialog.run();
		}
	}

/**
 * É carregada uma janela, logo após clicar no botão Rec_GERAR, e tem como objetivo identificar se o recibo emitido é de 
 * crédito ou débito além de confirmar, através do código, o funcionário/digitador que está gerando o recibo.
 * \param tipo é a identificação do tipo de recibo que está sendo emitido.\n
 * 1 - Entrada\n
 * 2 - Saída\n
 * 3 - Entrada Títulos\n
 */
void RECIBO::Funcionario(int tipo)
	{
	Gtk::Label *L_Dig;
	Gtk::RadioButton::Group Deb_Cred;
	Gtk::RadioButton *Debito;
	Gtk::VBox *VB_FunDig, *VB2_FunDig;
	Gtk::HBox *HB_FunDig, *HB;
	Gtk::Frame *F_FunDig;
	char *hora;
	string HORA("17:10:00");
	int checar_hora;

	hora = new char[9];
	hora = agora();
	//cout << hora << endl;
	//cout << HORA << endl;
	checar_hora = HORA.compare (hora);
	delete hora;
	this->Fun_Dig = new Gtk::Window();
	this->Fun_Dig->set_title (Glib::ustring("..::Informações::.."));
	this->Fun_Dig->set_default_size (200,150);
	this->Fun_Dig->set_icon(this->ponteiro_icon);
	this->Fun_Dig->set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
	this->Fun_Dig->set_position(Gtk::WIN_POS_CENTER);
	this->Fun_Dig->signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),3));
	HB = new Gtk::HBox(false,0);

	//Bloco do débito e crédito
	VB_FunDig = new Gtk::VBox(false,0);
	F_FunDig = new Gtk::Frame(Glib::ustring("Débito/Crédito"));
	HB_FunDig = new Gtk::HBox(false,0);
	Debito = new Gtk::RadioButton();
	L_Dig = new Gtk::Label();
	L_Dig->set_text("<span foreground=\"#36723C\" font_weight=\"bold\" size=\"12288\"> Débito </span>");
 	L_Dig->set_use_markup(true);
	//Debito->modify_fg(Gtk::STATE_NORMAL, Gdk::Color("green"));
	Debito->add(*L_Dig);
	Deb_Cred = Debito->get_group();
	Credito = new Gtk::RadioButton(Deb_Cred);
	L_Dig =new Gtk::Label();
	L_Dig->set_text("<span foreground=\"red\" font_weight=\"bold\" size=\"12288\"> Crédito </span>");
 	L_Dig->set_use_markup(true);
	Credito->add(*L_Dig);
	HB_FunDig->pack_start(*Debito,false,false,0);
	HB_FunDig->pack_start(*Credito,false,false,0);
	F_FunDig->add(*HB_FunDig);
	VB_FunDig->pack_start(*F_FunDig,true,false,0);

	HB->pack_start(*VB_FunDig,true,false,0);
	if (checar_hora <= 0)
		{
		Debito->set_sensitive (false);
		Credito->set_active (true);
		}
	if (this->B_Cred->get_active ())
		{
		Credito->set_active (true);
		}
	//Fim do Bloco débito e crédito

	//Bloco do Funcionário
	F_FunDig = new Gtk::Frame(Glib::ustring("Digitador:"));
	VB2_FunDig = new Gtk::VBox(false,0);
	HB_FunDig = new Gtk::HBox(false,0);
	L_Dig = new Gtk::Label(Glib::ustring("Código: "));
	HB_FunDig->pack_start(*L_Dig,false,false,0);
	E_CodFun = new Gtk::Entry();
	E_CodFun->set_visibility(false);
	E_CodFun->set_invisible_char('*');
	E_CodFun->signal_activate().connect(sigc::mem_fun(*this,&RECIBO::Checar_Digitador));
	HB_FunDig->pack_start(*E_CodFun,true,true,0);
	//Passando o próximo objeto a ser setado pelo foco da janela caso acha sinal do clique
	Debito->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::tabular2));
	//Passando o próximo objeto a ser setado pelo foco da janela caso acha sinal do clique			
	Credito->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::tabular2));
	VB2_FunDig->pack_start(*HB_FunDig,true,true,0);
	HB_FunDig = new Gtk::HBox(false,0);
	L_Dig = new Gtk::Label(Glib::ustring("Nome: "));
	HB_FunDig->pack_start(*L_Dig,false,false,0);
	E_NomeFun = new Gtk::Entry();
	E_NomeFun->set_editable(false);
	HB_FunDig->pack_start(*E_NomeFun,true,true,0);
	VB2_FunDig->pack_start(*HB_FunDig,true,true,0);
	F_FunDig->add(*VB2_FunDig);
	VB_FunDig->pack_start(*F_FunDig,false,false,0);
	HB_FunDig = new Gtk::HBox(true,0);
	Fun_OK = new Gtk::Button(Gtk::Stock::OK);
	Fun_OK->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::gerar_numero),tipo));
	Fun_CANCEL =  new Gtk::Button(Gtk::Stock::CANCEL);
	Fun_CANCEL->signal_clicked().connect (sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),3));
	HB_FunDig->pack_start(*Fun_OK,true,true,0);
	HB_FunDig->pack_start(*Fun_CANCEL,true,true,0);
	VB_FunDig->pack_start(*HB_FunDig,true,false,0);

	HB->pack_start(*VB_FunDig,true,false,0);
	//Fim Bloco do Funcionário

	Fun_Dig->add(*HB);
	Fun_Dig->set_focus(*E_CodFun);
	Fun_Dig->show_all();
	}

/**
 * Após inserir todas as informações na base de dados retorna o número gerado pelo Banco de Dados
 * de recibo sequencialmente gerado conforme o tipo.
 * \param tipo identifica o tipo de recibo que será gravado.\n
 * 1 - Entrada, assume o valor para o lançamento e_s 1\n
 * 2 - Saída, assume o valor para o lançamento e_s 2\n
 * 3 - Entrada Título, assume o valor para o lançamento e_s 1\n
 */
void RECIBO::gerar_numero(int tipo)
	{
	Gtk::TreeModel::Row reg;
	type_children::iterator i;
	int j, it, cod_teste;
	float valor[5], vlr_f;
	string AUX, SQL, deb_cred, REC, TIPO;
	char *sql, *aux;
	vector<string> linha;

	//janela->hide();
	//cout << this->cod_fun_dig << endl;
	this->checar_ano(tipo);
	TIPO.clear();
	aux = new char[10];
	if (tipo == 3)
		{
		strcpy(aux,"1");
		}
	else
		{
		sprintf(aux,"%d",tipo);
		}
	TIPO.append(aux);
	delete aux;
	deb_cred.clear();
	deb_cred = "'D','";
	deb_cred.append(hoje());
	deb_cred += "'";
	if (this->Credito->get_active() == 1)
		{
		deb_cred = "'C',null";
		}
	//cout << deb_cred << endl
	aux = new char[20];
	strcpy(aux,"begin;");
	this->conexao->executar(aux);
	delete aux;
	SQL.clear();
	if (tipo == 3)
		{
		SQL += "insert into caixa.lancamentos(e_s,rec,data,cod_cli,cod_fun,desconto,total,total_liq,tipo,data_qt,funjecc3,protocolo,data_p,obs,s_issqn) values(";
		}
	else
		{
		SQL += "insert into caixa.lancamentos(e_s,rec,data,cod_cli,cod_fun,desconto,total,total_liq,tipo,data_qt,funjecc3,obs,s_issqn) values(";
		}
	SQL += TIPO + ",nextval('caixa.seq_rec'),'";
	SQL.append(hoje());
	SQL += "',"+Rec_CliCod->get_text()+",";
	aux = new char[16];
	itoa(this->cod_fun_dig,aux,10);
	SQL.append(aux);
	delete aux;
	SQL += ",'";
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_desc);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "','";
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_total);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;	
	SQL += "','";
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_subtotal);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "',"+deb_cred+",'";
	aux = new char[32];
	sprintf(aux,"%0.3f",((this->vlr_funjecc*0.03)/0.10));
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	if (tipo == 3)
		{
		SQL += "',"+this->numero_protocolo+",'"+this->data_protocolo;
		}
	SQL += "','" +this->Rec_OBS->get_text () + "','";
	if (this->s_issqn)
		{
		this->vlr_bsissqn = (this->vlr_issqn*100)/5;
		}
	else
		{
		this->vlr_bsissqn = 0.0;
		}
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_bsissqn);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "') returning rec;";
	cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (this->conexao->registros > 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			REC.clear();
			//REC = "1";
			REC = linha.at(0);
			}
		}
	type_children crianca = this->dados_serv->children();
	SQL.clear();
	for(i = crianca.begin(); i != crianca.end(); ++i)
		{
  		reg = *i;
  		if(reg)
			{
			SQL += "insert into caixa.entrada values(" + TIPO + "," + REC + ",'";
			SQL.append(hoje());
			SQL += "',";
			aux = new char[32];
			cod_teste = reg[dados_arv.cod_servico];
			sprintf(aux,"%d",cod_teste);
			cout << cod_teste << " " << aux << endl;
			SQL.append(aux);
			delete aux;
			SQL += ","+reg[dados_arv.campo[2]]+",'";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[3]];
			valor[0] = atof(AUX.c_str());
			//cout << valor[0] << endl;
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[0]);
			aux[strlen(aux)-1] = '\0';
			//cout << aux << endl;
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[4]];
			valor[1] = atof(AUX.c_str());
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[1]);
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[5]];
			valor[2] = atof(AUX.c_str());
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[6]];
			valor[3] = atof(AUX.c_str());
			valor[4] = valor[0]+valor[2]+valor[3];
			//cout << valor[4] << endl;
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[4]);
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[4]-valor[1]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[2]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[3]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL += "');";
			}
		}
	cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		Rec_NUMERO->set_text(REC);
		Rec_IMPRIMIR->set_sensitive(true);
		Rec_GERAR->set_sensitive (false);
		this->Recibo->set_focus (*this->Rec_IMPRIMIR);
		Fun_Dig->hide();
		}
	aux = new char[20];
	strcpy(aux,"commit;");
	this->conexao->executar(aux);
	delete aux;
	}

/**
 * Checa se o código digitado na tela de Checagem existe na base de dados.
 */
void RECIBO::Checar_Digitador()
	{
	string SQL, AUX;
	char *sql, *aux;
	bool retorno;
	vector<string> linha;
		
	AUX.clear();
	AUX = this->E_CodFun->get_text();
	SQL.clear();
	SQL = "select u_login from cadastro.funcionario where cod_fun="+AUX;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	retorno = false;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (this->conexao->registros > 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			retorno = true;
			this->cod_fun_dig = atoi(AUX.c_str());
			AUX.clear();
			AUX = linha.at(0);
			}
		}
	if (retorno)
		{
		this->E_NomeFun->set_text(Glib::ustring(AUX));
		this->Fun_Dig->set_focus(*this->Fun_OK);
		}
	else
		{
		this->Fun_Dig->set_focus(*this->E_CodFun);
		this->E_CodFun->set_text ("");
		this->E_NomeFun->set_text ("");
		Gtk::MessageDialog dialog(*this->Fun_Dig, Glib::ustring("Não Encontrado"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring("Este Código de Funcionário não encontra-se Cadastrado!"));
		dialog.run();
		}

	}

/**
 * É acionado quando clicado no botão Rec_IMPRIMIR, chama a Classe IMPRIMIR gerando a visualização
 * do recibo para ser impresso.
 * \param tipo usado para identificar o tipo de recibo que será impresso.
 */
void RECIBO::imprimir(int tipo)
	{
	int recibo, tp;
	string AUX;
	char *aux;
	IMPRIMIR *print_view;

	if (tipo == 4)
		{
		recibo = atoi(this->numero_recibo.c_str());
		AUX.clear();
		AUX = this->data_recibo;
		tp = 1;
		}
	else if (tipo == 5)
		{
		AUX.clear();
		AUX = this->SelNumero->get_text();
		recibo = atoi(AUX.c_str());
		AUX.clear();
		AUX = this->SelData->get_text();
		aux = new char[32];
		strcpy(aux,AUX.c_str());
		AUX.clear();
		AUX = data_formatada(aux,1);
		tp = 1;
		}
	else
		{
		AUX.clear();
		AUX = this->Rec_NUMERO->get_text();
		recibo = atoi(AUX.c_str());
		AUX.clear();
		AUX.append(hoje());
		tp = tipo;
		}
	print_view = new IMPRIMIR(this->conexao,tp,AUX,recibo);
	print_view->set_modal();
	if (tipo == 5)
		{
		this->SelRec->hide();
		}
	else
		{
		this->Recibo->hide();
		//this->gerar_recibo(tipo);
		}
	}

/**
 * É utilizado para inserir as informações do recibo de saída.
 * \param modo indica se é uma inserção(0) ou atualização(1)
 */
void RECIBO::saida(int modo)
	{
	string SQL, AUX;
	char *sql, *aux, *valor;
	vector<string> linha;

	if (modo == 0)
		{
		this->checar_ano(2);
		SQL.clear();
		SQL = "begin;";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		//cout << sql << endl;
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		else
			{
			//Lançamento Principal
			SQL.clear();
			SQL = "insert into caixa.lancamentos (e_s,rec,data,cod_cli,cod_fun,total,total_liq) values (2,nextval('caixa.saida_inc'),'";
			SQL.append(hoje());
			SQL += "'," + this->Rec_CliCod->get_text() +",";
			aux = new char[5];
			sprintf(aux,"%d",cod_fun);
			SQL.append(aux);
			delete aux;
			AUX.clear();
			AUX = this->Rec_Total->get_text ();
			valor = new char[AUX.length()+1];
			sprintf(valor,"%s",AUX.c_str());
			SQL += ",'"+valor_formatado(valor,1)+"','"+valor_formatado(valor,1)+"') returning rec; ";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			//cout << sql << endl;
			delete sql;
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				conexao->resultado();
				linha = conexao->resultados.at(0);
				//Detalhamento
				SQL.clear();
				SQL = "insert into caixa.saida values(2,";
				SQL += linha.at(0);
				SQL += ",'";
				SQL.append(hoje());
				SQL += "',";
				aux = new char[32];
				sprintf(aux,"%d",this->cod_servico);
				SQL.append(aux);
				delete aux;
				SQL += ",'" + valor_formatado(valor,1) + "','" + this->RecSer_Hist->get_text() + "');";
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				this->conexao->executar(sql);
				//cout << sql << endl;
				delete sql;
				if (this->conexao->query_result == 3)
					{
					cout << this->conexao->mensagem << endl;
					}
				}
			delete valor;
			}
		SQL.clear();
		SQL = "commit;";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		//cout << sql << endl;
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		this->saida_acao(0);
		}
	else if (modo == 1)
		{
		SQL.clear();
		SQL = "update caixa.lancamentos set cod_cli="+this->Rec_CliCod->get_text ()+",cod_fun=";
		aux = new char[5];
		sprintf(aux,"%d",cod_fun);
		SQL.append(aux);
		delete aux;
		AUX.clear();
		AUX = this->Rec_Total->get_text();
		valor = new char[AUX.length()+1];
		sprintf(valor,"%s",AUX.c_str());
		SQL += ",total='"+ valor_formatado(valor,1) +"',total_liq='"+ valor_formatado(valor,1) +"' where e_s=2 and data='"+this->saida_data+"' and rec="+this->saida_numero+";";
		SQL += "update caixa.saida set cod_serv=";
		aux = new char[32];
		sprintf(aux,"%d",this->cod_servico);
		SQL.append(aux);
		delete aux;
		SQL += ",valor='"+valor_formatado(valor,1) +"',historico_complementar='"+this->RecSer_Hist->get_text ()+"' where e_s=2 and data='"+this->saida_data+"' and rec="+this->saida_numero+";";
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			}
		else
			{
			//this->carregar_saida ();
			this->saida_acao(0);
			}
		delete valor;
		}
	}

/**
 * Este método é utilizado no caso de recibo de Entrada Título, pois ele atualiza o
 * endereço do cliente conforme foi apontado no protesto.
 * \param codigo é o código do cliente já cadastrado no sistema.
 */
void RECIBO::update_apresentante (string codigo)
	{
	string SQL, AUX;
	char *sql;

	AUX.clear();
	AUX = this->Rec_End->get_text();
	SQL.clear();
	SQL = "update cadastro.clientes set endereco='"+AUX+"' where cod_cli="+codigo;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	}

/**
 * É utilizado especificamente para inclusão de serviços importados no sistema de protesto,
 * ou seja, são dados externos dos protocolos apontados.
 * \param codigo é o código de entrada do serviço.
 * \param valores é o valor nominal do serviço já calculado pelo sistema.
 */
void RECIBO::incluir_servicos(int codigo, string valores)
	{
	char *aux;
	int quantidade;
	float valor_u, desc, valor, funjecc10, issqn;
	string AUX;

	ato_gratuito = false;
	if (Ato_Gratuito->get_active())
		{
		ato_gratuito = true;
		}
	this->itens++;
	this->celula = *(this->dados_serv->append());
	switch(codigo)
		{
		case 12:
		case 13:
			{
			switch(codigo)
				{
				case 12:
					{
					this->celula[dados_arv.cod_servico] = 8;
					this->celula[dados_arv.campo[0]] = Glib::ustring("12");
					this->celula[dados_arv.campo[1]] = Glib::ustring("PROTOCOLO");
					break;
					}
				case 13:
					{
					this->celula[dados_arv.cod_servico] = 9;
					this->celula[dados_arv.campo[0]] = Glib::ustring("13");
					this->celula[dados_arv.campo[1]] = Glib::ustring("PROTESTO");
					break;
					}
				}
			this->celula[dados_arv.campo[2]] = Glib::ustring("1");
			quantidade = 1;
			valor_u = char2double(valores.c_str());
			if (ato_gratuito)
				{
				valor_u = 0;
				}
			valor = valor_u * (float) quantidade;
			AUX.clear();
			aux = new char[32];
			sprintf (aux,"%0.3f",valor);
			aux[strlen(aux)-1] = '\0';
			AUX.append(aux);
			this->celula[dados_arv.campo[3]] = Glib::ustring(AUX);
			this->celula[dados_arv.campo[4]] = Glib::ustring("0,00");
			desc = 0,00;
			funjecc10 = valor/10,0;
			issqn = valor/20,0;
			aux = new char[50];
			sprintf(aux, "%.2f",funjecc10);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->celula[dados_arv.campo[5]]= Glib::ustring(AUX);
			aux = new char[50];
			sprintf(aux, "%.2f",issqn);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->celula[dados_arv.campo[6]]= Glib::ustring(AUX);
			break;
			}
		case 32:
		case 53:
		case 54:
		case 60:
			{
			switch(codigo)
				{
				case 32:
					{
					this->celula[dados_arv.cod_servico] = 41;
					this->celula[dados_arv.campo[0]] = Glib::ustring("32");
					this->celula[dados_arv.campo[1]] = Glib::ustring("FUNADEP");
					this->celula[dados_arv.campo[2]] = Glib::ustring("2");
					quantidade = 2;
					break;
					}
				case 53:
					{
					this->celula[dados_arv.cod_servico] = 27;
					this->celula[dados_arv.campo[0]] = Glib::ustring("53");
					this->celula[dados_arv.campo[1]] = Glib::ustring("INTIMAÇÃO");
					this->celula[dados_arv.campo[2]] = Glib::ustring("1");
					quantidade = 1;
					break;
					}
				case 54:
					{
					this->celula[dados_arv.cod_servico] = 28;
					this->celula[dados_arv.campo[0]] = Glib::ustring("54");
					this->celula[dados_arv.campo[1]] = Glib::ustring("EDITAL");
					this->celula[dados_arv.campo[2]] = Glib::ustring("1");
					quantidade = 1;
					break;
					}
				case 60:
					{
					this->celula[dados_arv.cod_servico] = 34;
					this->celula[dados_arv.campo[0]] = Glib::ustring("60");
					this->celula[dados_arv.campo[1]] = Glib::ustring("REMESSA");
					this->celula[dados_arv.campo[2]] = Glib::ustring("1");
					quantidade = 1;
					break;
					}
				}
			
			//cout << valores << endl;
			valor_u = char2double(valores.c_str());
			if (ato_gratuito)
				{
				valor_u = 0;
				}
			valor = valor_u * (float) quantidade;
			AUX.clear();
			aux = new char[32];
			sprintf (aux,"%0.3f",valor);
			aux[strlen(aux)-1] = '\0';
			AUX.append(aux);
			this->celula[dados_arv.campo[3]] = Glib::ustring(AUX);
			this->celula[dados_arv.campo[4]] = Glib::ustring("0,00");
			desc = 0,00;
			funjecc10 = 0,00;
			issqn = 0,00;
			aux = new char[50];
			sprintf(aux, "%.2f",funjecc10);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->celula[dados_arv.campo[5]]= Glib::ustring(AUX);
			aux = new char[50];
			sprintf(aux, "%.2f",issqn);
			AUX.clear();
			AUX.append(aux);
			delete aux;
			this->celula[dados_arv.campo[6]]= Glib::ustring(AUX);
			break;
			}
		}
	//Valor Subtotal
	this->vlr_subtotal += valor;
	//valor Total
	if (this->s_issqn)
		{
		this->vlr_total += ( ( valor + funjecc10 ) - desc );
		}
	else
		{
		this->vlr_total += ( ( valor + funjecc10 + issqn ) - desc );
		}
	//Total Funjecc10
	this->vlr_funjecc += funjecc10;
	//Total ISSQN
	this->vlr_issqn += issqn;
	//total desconto
	this->vlr_desc += desc;
	//Setando Sub-Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_subtotal);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_SubT->set_text(Glib::ustring(AUX));
	//Setando Desconto
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_desc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Desconto->set_text(Glib::ustring(AUX));
	//Setando Funjecc 10
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_funjecc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Funjecc->set_text(Glib::ustring(AUX));
	//Setando ISSQN
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_issqn);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_ISSQN->set_text(Glib::ustring(AUX));
	//Setando Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_total);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Total->set_text(Glib::ustring(AUX));
	this->alterado = false;
	}

/**
 * Nesse método será solicitado um número de recibo e data, para visualização.
 */
void RECIBO::editar_recibo ()
	{
	Gtk::Frame *F_SEL;
	Gtk::VBox *V_SEL[2];
	Gtk::HBox *H_SEL;
	Gtk::Label *L_SEL;
	this->SelRec = new Gtk::Window();
	this->SelRec->set_default_size (180,120);
	this->SelRec->set_icon(this->ponteiro_icon);
	this->SelRec->set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
	this->SelRec->set_position(Gtk::WIN_POS_CENTER);
	this->SelRec->set_title(Glib::ustring("..::Editar Recibo::.."));
	this->SelRec->signal_hide().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),4));
	V_SEL[0] = new Gtk::VBox(false,0);
	F_SEL = new Gtk::Frame(Glib::ustring("Dados do Recibo"));
	V_SEL[1] = new Gtk::VBox(false,0);
	H_SEL = new Gtk::HBox(false,0);
	L_SEL = new Gtk::Label(Glib::ustring ("Data:      "));
	H_SEL->pack_start(*L_SEL,false,false,0);
	this->SelData = new Gtk::Entry();
	this->SelData->set_size_request(127,27);
	//this->SelData->set_text("04/01/2012");
	this->SelData->set_max_length(10);
	this->SelData->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::data_mascara),1));
	this->SelData->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),5));
	this->EntryData = Gtk::EntryCompletion::create();
	this->SelData->set_completion(this->EntryData);
	this->dados_datas = Gtk::ListStore::create(this->dados_arv);
	this->EntryData->set_model(this->dados_datas);
	this->preparar_dados(6,1);
	H_SEL->pack_start(*this->SelData,false,false,0);
	V_SEL[1]->pack_start(*H_SEL,false,false,0);
	H_SEL = new Gtk::HBox(false,0);
	L_SEL = new Gtk::Label(Glib::ustring("Número: "));
	H_SEL->pack_start(*L_SEL,false,false,0);
	this->SelNumero = new Gtk::Entry();
	this->SelNumero->set_size_request(127,27);
	this->SelNumero->signal_changed().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::digito),7));
	this->SelNumero->signal_activate().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::tabular),6));
	H_SEL->pack_start(*this->SelNumero,false,false,0);
	V_SEL[1]->pack_start(*H_SEL,false,false,0);
	F_SEL->add(*V_SEL[1]);
	V_SEL[0]->pack_start(*F_SEL,false,false,0);
	H_SEL = new Gtk::HBox(false,0);
	this->SelIMP = new Gtk::Button(Gtk::Stock::PRINT);
	this->SelIMP->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::imprimir),5));
	H_SEL->pack_end(*this->SelIMP,true,true,0);
	this->SelCancel = new Gtk::Button(Gtk::Stock::CANCEL);
	this->SelCancel->signal_clicked().connect(sigc::bind<int>(sigc::mem_fun(*this,&RECIBO::sair),4));
	H_SEL->pack_end(*this->SelCancel,true,true,0);
	this->SelOK = new Gtk::Button(Gtk::Stock::OK);
	this->SelOK->signal_clicked().connect(sigc::mem_fun(*this,&RECIBO::carregar_recibo));
	H_SEL->pack_end(*this->SelOK,true,true,0);
	V_SEL[0]->pack_end(*H_SEL,false,true,0);
	this->SelRec->add(*V_SEL[0]);
	this->SelRec->show_all();
	Gtk::Main::run(*this->SelRec);
	}

/**
 * \param w Gtk::Entry passada por referência.
 * \param n posição que será assumida pelo cursor.
 */
void RECIBO::set_posicao (Gtk::Entry * w, int n)
	{
	Glib::signal_idle().connect(sigc::bind_return(sigc::bind<int>(sigc::mem_fun (*w,&Gtk::Entry::set_position), n), false));
	}

/**
 * \param onde identifica qual Gtk::Entry será checada.\n
 * 1 - RECIBO::SelData
 */
void RECIBO::data_mascara (int onde)
	{
	string data_dg, mascara;
	int tam;
	bool mudou;
	mudou = false;
	if (this->entry_ativa != onde)
		{
		this->entry_ativa = onde;
		mudou = true;
		}
	//cout << this->pos_entry << endl;
	switch(onde)
		{
		case 1:
			{
			if (mudou)
				{
				this->pos_entry = this->SelData->get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->SelData->get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->SelData->set_text(data_dg);
			this->set_posicao(this->SelData,tam);
			this->pos_entry = tam;
			break;
			}
		case 2:
			{
			if (mudou)
				{
				this->pos_entry = this->Prot_Data->get_text_length();
				}
			mascara.clear();
			mascara = "##/##/####";
			data_dg.clear();
			data_dg = this->Prot_Data->get_text();
			tam = data_dg.length();
			if(isdigit(data_dg[tam-1]) || (data_dg[tam-1] == '/'))
				{
				if ((this->pos_entry > 0) && (this->pos_entry > tam))
					{
					this->pos_entry--;
					data_dg[tam]='\0';
					}
				else if (tam < 10)
					{
					if(mascara[tam] !='#')
						{
						data_dg += mascara [tam];
						}
					if((data_dg[tam-1] == '/')&&(data_dg[tam-2] == '/'))
						{
						data_dg[tam-1] = '\0';
						}
					tam++;
					}
				}
			else
				{
				data_dg[tam-1]='\0';
				tam--;
				}
			this->Prot_Data->set_text(data_dg);
			this->set_posicao(this->Prot_Data,tam);
			this->pos_entry = tam;
			break;
			}
		}
	}

/**
 * Faz a checagem de início de ano, zerando os contadores de recibo.
 */
void RECIBO::checar_ano(int e_s)
	{
	char *aux, *sql;
	string SQL, AUX;

	aux = new char[10];
	strcpy(aux,"begin;");
	this->conexao->executar(aux);
	delete aux;
	AUX.clear();
	AUX = hoje();
	SQL.clear();
	SQL = "select rec from caixa.lancamentos where e_s=";
	if (e_s == 3)
		{
		SQL += "1";
		}
	else
		{
		aux = new char[10];
		sprintf (aux,"%d",e_s);
		SQL.append(aux);
		delete aux;
		}
	SQL += " and data >= '"+ AUX.substr(0,4) +"-01-01' and data <= '"+ AUX.substr(0,4) +"-12-31' limit 1 offset 0;";
	sql = new char[SQL.length()+1];
	//cout << sql << endl;
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (this->conexao->registros == 0)
			{
			SQL.clear();
			switch(e_s)
				{
				case 1:
				case 3:
					{
					SQL = "alter sequence caixa.seq_rec restart with 1;";
					break;
					}
				case 2:
					{
					SQL = "alter sequence caixa.saida_inc restart with 1;";
					break;
					}
				}
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			this->conexao->executar(sql);
			delete sql;
			}
		}
	aux = new char[10];
	strcpy(aux,"commit;");
	this->conexao->executar(aux);
	delete aux;
	}

/**
 * Preenche as informações para edição de um recibo selecionado.\n
 */
void RECIBO::carregar_recibo()
	{
	char *aux;
	this->data_recibo = this->SelData->get_text();
	aux = new char[this->data_recibo.length()+1];
	strcpy(aux,this->data_recibo.c_str());
	this->data_recibo = data_formatada(aux,1);
	//cout << this->data_recibo << " - ";
	this->numero_recibo = this->SelNumero->get_text();
	//cout << this->numero_recibo << endl;
	this->SelRec->hide();
	this->gerar_recibo(4);
	}

/**
 * Utilizado para liberar os campos do recibo para edição.
 */
void RECIBO::liberar_alteracao ()
	{
	//Campos do Cliente.
	this->Rec_CliCod->set_editable(true);
	this->Rec_Cliente->set_editable(true);
	//Campos dos Serviços
	this->Rec_SerCod->set_editable(true);
	this->Rec_Servico->set_editable(true);
	this->Rec_SerQtd->set_editable(true);
	this->Rec_SerVUni->set_editable(true);
	this->Rec_SerDesc->set_editable(true);
	this->Rec_CadServ->set_sensitive (true);
	//Listagem dos Serviços
	this->Rec_Dados->set_sensitive(true);
	//Botões
	this->Rec_GERAR->set_sensitive(false);
	this->Rec_SALVAR->set_sensitive(true);
	this->Rec_IMPRIMIR->set_sensitive(true);
	//Setando o Foco
	this->Recibo->set_focus(*this->Rec_IMPRIMIR);
	}

/**
 * Utilizado para atualizar os dados de um recibo alterado e liberar a impressão.
 */
void RECIBO::salvar_alteracao ()
	{
	bool controle;
	Gtk::TreeModel::Row reg;
	type_children::iterator i;
	string SQL, AUX, MSG;
	char *sql, *aux;
	int it;
	float valor[5];

	controle = true;
	//Iniciando bloco
	aux = new char[20];
	strcpy(aux,"begin;");
	this->conexao->executar(aux);
	delete aux;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		MSG.clear();
		MSG = this->conexao->mensagem;
		controle = false;
		}

	//Atualizando registro
	SQL.clear();
	AUX.clear();
	AUX = this->Rec_CliCod->get_text();
	SQL = "update caixa.lancamentos set cod_cli="+AUX+",desconto='";
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_desc);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "',total='";
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_total);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "',total_liq='";
	aux = new char[32];
	sprintf(aux,"%0.3f",(this->vlr_total+this->vlr_desc));
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "',funjecc3='";
	aux = new char[32];
	sprintf(aux,"%0.3f",((this->vlr_funjecc*0.03)/0.10));
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "',obs='"+this->Rec_OBS->get_text()+"',s_issqn='";
	if (this->s_issqn)
		{
		this->vlr_bsissqn = (this->vlr_issqn*100)/5;
		}
	else
		{
		this->vlr_bsissqn = 0.0;
		}
	aux = new char[32];
	sprintf(aux,"%0.3f",this->vlr_bsissqn);
	aux[strlen(aux)-1] = '\0';
	SQL += valor_formatado(aux,1);
	delete aux;
	SQL += "' where e_s=1 and rec="+this->numero_recibo+" and data='"+this->data_recibo+"';";
	//Lançando Serviços
	SQL += "delete from caixa.entrada where e_s=1 and rec="+this->numero_recibo+" and data='"+this->data_recibo+"';";
	type_children crianca = this->dados_serv->children();
	for(i = crianca.begin(); i != crianca.end(); ++i)
		{
  		reg = *i;
  		if(reg)
			{
			SQL += "insert into caixa.entrada values(1," +this->numero_recibo+ ",'"+this->data_recibo+"',";
			aux = new char[32];
			itoa(reg[dados_arv.cod_servico],aux,10);
			SQL.append(aux);
			delete aux;
			SQL += ","+reg[dados_arv.campo[2]]+",'";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[3]];
			valor[0] = char2double(AUX.c_str());
			//cout << valor[0] << endl;
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[0]);
			aux[strlen(aux)-1] = '\0';
			//cout << aux << endl;
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[4]];
			valor[1] = char2double(AUX.c_str());
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[1]);
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[5]];
			valor[2] = char2double(AUX.c_str());
			AUX.clear();
			AUX = ""+reg[dados_arv.campo[6]];
			valor[3] = char2double(AUX.c_str());
			valor[4] = valor[0]+valor[2]+valor[3];
			//cout << valor[4] << endl;
			aux = new char[32];
			sprintf(aux,"%0.3f",valor[4]);
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[4]-valor[1]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[2]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL +="','";
			aux = new char[32];
			sprintf(aux,"%0.3f",(valor[3]));
			aux[strlen(aux)-1] = '\0';
			SQL += valor_formatado(aux,1);
			delete aux;
			SQL += "');";
			}
		}
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		MSG.clear();
		MSG = this->conexao->mensagem;
		controle = false;
		}
		
	//Finalizando bloco
	aux = new char[20];
	strcpy(aux,"commit;");
	this->conexao->executar(aux);
	delete aux;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		MSG.clear();
		MSG = this->conexao->mensagem;
		controle = false;
		}

	if (controle)
		{
		this->Recibo->set_focus(*this->Rec_IMPRIMIR);
		this->voltar_edicao();
		}
	else
		{
		Gtk::MessageDialog dialog(*this->Recibo, Glib::ustring("Erro ao salvar alteração do recibo"), false, Gtk::MESSAGE_ERROR);
		dialog.set_secondary_text(Glib::ustring(MSG));
		dialog.run();
		}
	}

/**
 * Volta para reedição após salvar na base de dados.
 */
void RECIBO::voltar_edicao ()
	{
	this->carregar_dados(1,4);
	//Campos do Cliente.
	this->Rec_CliCod->set_editable(false);
	this->Rec_Cliente->set_editable(false);
	this->carregar_dados(2,4);
	//Campos dos Serviços
	this->Rec_SerCod->set_editable(false);
	this->Rec_Servico->set_editable(false);
	this->Rec_SerQtd->set_editable(false);
	this->Rec_SerVUni->set_editable(false);
	this->Rec_SerDesc->set_editable(false);
	this->Rec_CadServ->set_sensitive (false);
	//Listagem dos Serviços
	this->Rec_Dados->set_sensitive(false);
	//Botões
	this->Rec_GERAR->set_sensitive(true);
	this->Rec_SALVAR->set_sensitive(false);
	this->Rec_IMPRIMIR->set_sensitive(true);
	}

/**
 * Remove um serviço listado em um TreeViewColumn e atualiza os valores do recibo.
 */
void RECIBO::remover_servico ()
	{
	string AUX;
	char *aux;
	//Atualizando valores
	this->itens--;
	//Valor Subtotal
	this->vlr_subtotal -= servicos.valor;
	//total desconto
	this->vlr_desc -= servicos.desconto;
	if (servicos.fj10)
		{
		//Total Funjecc10
		this->vlr_funjecc = this->vlr_subtotal*0.10;
		//Total ISSQN
		this->vlr_issqn = this->vlr_subtotal*0.05;
		//valor Total
		if (this->s_issqn)
			{
			this->vlr_total = ( ( this->vlr_subtotal + this->vlr_funjecc ) - this->vlr_desc );
			}
		else
			{
			this->vlr_total = ( ( this->vlr_subtotal + this->vlr_funjecc + this->vlr_issqn ) - this->vlr_desc );
			}
		}
	else
		{
		this->vlr_total = ( ( this->vlr_subtotal + this->vlr_funjecc + this->vlr_issqn ) - this->vlr_desc );
		}
	//Setando Sub-Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_subtotal);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_SubT->set_text(Glib::ustring(AUX));
	//Setando Desconto
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_desc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Desconto->set_text(Glib::ustring(AUX));
	//Setando Funjecc 10
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_funjecc);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Funjecc->set_text(Glib::ustring(AUX));
	//Setando ISSQN
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_issqn);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_ISSQN->set_text(Glib::ustring(AUX));
	//Setando Total
	AUX.clear();
	aux = new char[32];
	sprintf (aux,"%0.3f",this->vlr_total);
	aux[strlen(aux)-1] = '\0';
	AUX.append(aux);
	this->Rec_Total->set_text(Glib::ustring(AUX));
	this->alterado = false;
	limpar_form_servico(2);
	this->dados_serv->erase(this->reg_selecionado);
	this->Rec_AltServ->set_sensitive (false);
	this->Rec_DelServ->set_sensitive (false);
	this->Rec_CadServ->set_sensitive (true);
	this->Recibo->set_focus(*this->Rec_SerCod);
	}

/**
 * \param modo indica como será consultado os dados na base do Notas
 */
void RECIBO::consultar_dados (int modo)
	{
	string SQL,AUX;
	char *sql, *aux;
	int resposta,x;
	bool doc_ok;
	Gtk::Dialog *dados;
	Gtk::HBox *Tela;
	Gtk::Label *Texto;
	Gtk::Entry *Documento;

	doc_ok = true;
	dados = new Gtk::Dialog("..::Consulta::..",this->Recibo);
	dados->set_size_request (250,80);
	dados->add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
	dados->add_button(Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL);
	Tela = new Gtk::HBox(false,0);
	Documento = new Gtk::Entry();
	Documento->signal_activate ().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::tabulacao),dados,dados->get_widget_for_response(Gtk::RESPONSE_OK)));
	if (modo == 1)
		{
		Texto = new Gtk::Label(Glib::ustring("Documento: "));
		Documento->signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&RECIBO::digitos),Documento));
		Documento->set_max_length (14);
		}
	else
		{
		Texto = new Gtk::Label(Glib::ustring("Ficha: "));
		Documento->signal_changed ().connect (sigc::bind(sigc::mem_fun(*this,&RECIBO::digitos),Documento));
		}
	Tela->pack_start(*Texto,false,false,0);
	Tela->pack_start(*Documento,true,true,0);
	dados->get_vbox ()->pack_start(*Tela,false,true,0);
	dados->show_all ();
	resposta = dados->run();
	switch(resposta)
		{
		case Gtk::RESPONSE_OK:
			{
			x = 11;
			this->conexao_nt = new BANCOMY(CONF_FILE2);
			SQL.clear();
			SQL = "select nome, endereco, cpf, cnpj, pess_fj from firmas where ";
			switch(modo)
				{
				case 1:
					{
					x = Documento->get_text_length ();
					AUX = Documento->get_text();
					if ( x == 11)
						{
						//cout << "CPF" << endl;
						aux = new char[16];
						strcpy(aux,AUX.c_str());
						aux = masc_doc(aux,1,2);
						SQL += "cpf='";
						SQL.append(aux);
						delete aux;
						SQL += "'";
						}
					else if (x == 14)
						{
						//cout << "CNPJ" << endl;
						aux = new char[19];
						strcpy(aux,AUX.c_str());
						aux = masc_doc(aux,2,2);
						SQL += "cnpj='";
						SQL.append(aux);
						delete aux;
						SQL += "'";
						}
					else
						{
						doc_ok = false;
						}
					break;
					}
				case 2:
					{
					SQL += "ficha=" + Documento->get_text();
					break;
					}
				}
			//cout << SQL << endl;
			if (doc_ok)
				{
				sql = new char[SQL.length()+1];
				strcpy(sql,SQL.c_str());
				this->conexao_nt->executar(sql,2);
				if (this->conexao_nt->query_result == 3)
					{
					cout << this->conexao_nt->mensagem << endl;
					}
				else
					{
					//cout << this->conexao_nt->registrosMY << endl;
					this->conexao_nt->resultado();
					this->carregar_ficha(this->conexao_nt->resultados);
					}
				}
			else
				{
				this->Recibo->set_focus(*this->Rec_CliCod);
				}
			delete this->conexao_nt;
			break;
			}
		}
	dados->hide();
	}

/**
 * 
 */
void RECIBO::carregar_ficha(string dados[5])
	{
	string SQL, AUX, TP_DOC[2];
	char *sql, *aux, *cpf, *cnpj;
	int i, c;
	bool acao;
	vector<string> linha;

/*	for (i=0; i < 5; i++)
		{
		cout << dados[i] << endl;
		}*/
	SQL.clear();
	SQL = "select cod_cli from cadastro.clientes where nome='"+dados[0]+"' or documento='";
	cpf = new char[dados[2].length()+1];
	strcpy(cpf,dados[2].c_str());
	cpf = masc_doc(cpf,1,1);
	cnpj = new char[dados[3].length()+1];
	strcpy(cnpj,dados[3].c_str());
	cnpj = masc_doc(cnpj,2,1);
	c = 0;
	for (i=0; i < strlen(cpf) ; i++)
		{
		if (cpf[i] != ' ')
			{
			c++;
			}
		}
//	cout << c << endl;
	TP_DOC[0].clear();
	TP_DOC[1].clear();
	if (c == 11)
		{
		TP_DOC[0] = "1";
		TP_DOC[1].append (cpf);
		SQL.append(cpf);
		}
	else
		{
		TP_DOC[0] = "2";
		TP_DOC[1].append (cnpj);
		SQL.append(cnpj);
		}
//	SQL.append(aux);
	SQL += "' order by cod_cli";
//	cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	acao = false;
	if (this->conexao->query_result == 3)
		{
		AUX.clear();
		AUX = this->conexao->mensagem;
		}
	else
		{
		if (this->conexao->registros > 0)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			acao = true;
			AUX.clear();
			AUX = linha.at(0);
			//cout << AUX << endl;
			}
		}
	if (acao)
		{
		SQL.clear();
		SQL = "update cadastro.clientes set nome='"+dados[0]+"',endereco='"+dados[1]+"',documento='"+TP_DOC[1]+"',tipo_doc="+TP_DOC[0]+" where cod_cli="+AUX;
		}
	else
		{
		SQL.clear();
		SQL = "insert into cadastro.clientes(cod_cli,nome,endereco,documento,tipo_doc) values(nextval('cadastro.clientes_nov_inc'),'"+dados[0]+"','"+dados[1]+"','"+TP_DOC[1]+"',"+TP_DOC[0]+") returning cod_cli";
		}
	//cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		if (!acao)
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			AUX.clear();
			AUX = linha.at(0);
			}
		this->Rec_CliCod->set_text(Glib::ustring(AUX));
		this->carregar_dados(1,1);
		}
	}

/**
 * Método utilizado para cancelamento de recibo.
 */
void RECIBO::cancelar_recibo()
	{
	cout << this->data_recibo << endl;
	cout << this->numero_recibo << endl;
	string SQL,AUX;
	char *sql, *aux;
	int resposta,x;
	bool doc_ok;
	Gtk::Dialog *dados;
	Gtk::HBox *Tela;
	Gtk::Label *Texto;
	Gtk::Label *Texto_Motivo;
	Gtk::Entry *Motivo;
	Gtk::Entry *Cod_Digitador;
	Gtk::Label *Nome_Digitador;

	dados = new Gtk::Dialog("..::Cancelamento de Recibo::..",this->Recibo);
	dados->set_size_request (300,-1);
	dados->add_button(Glib::ustring("Sim"),Gtk::RESPONSE_OK);
	dados->add_button(Glib::ustring("Não"),Gtk::RESPONSE_CANCEL);
	Tela = new Gtk::HBox(false,0);
	Texto = new Gtk::Label(Glib::ustring("Motivo: "));
	Motivo = new Gtk::Entry();
	Motivo->set_size_request (40,-1);
	Texto_Motivo = new Gtk::Label("");
	Tela->pack_start(*Texto,false,false,0);
	Tela->pack_start(*Motivo,false,false,0);
	Tela->pack_start(*Texto_Motivo,false,false,0);
	dados->get_vbox ()->pack_start(*Tela,false,true,0);
	Tela = new Gtk::HBox(false,0);
	Texto = new Gtk::Label(Glib::ustring("Digitador: "));
	Cod_Digitador = new Gtk::Entry();
	Cod_Digitador->set_size_request (40,-1);
	Nome_Digitador = new Gtk::Label("");
	Tela->pack_start(*Texto,false,false,0);
	Tela->pack_start(*Cod_Digitador,false,false,0);
	Tela->pack_start(*Nome_Digitador,false,false,0);
	dados->get_vbox ()->pack_start(*Tela,false,true,0);
	Tela = new Gtk::HBox(false,0);
	Texto = new Gtk::Label(Glib::ustring("Confirma Cancelamento?"));
	Tela->pack_start(*Texto,false,false,0);
	dados->get_vbox ()->pack_start(*Tela,false,true,0);
	//Sinais
	Motivo->signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&RECIBO::checagem_cancelamento),dados,Motivo,Texto_Motivo,Cod_Digitador,1));
	Cod_Digitador->signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&RECIBO::checagem_cancelamento),dados,Cod_Digitador,Nome_Digitador,dados->get_widget_for_response (Gtk::RESPONSE_OK),2));
	dados->show_all ();
	resposta = dados->run();
	switch(resposta)
		{
		case Gtk::RESPONSE_OK:
			{
			SQL.clear();
			SQL = "update caixa.lancamentos set status=false, motivo=";
			AUX.clear();
			AUX = Motivo->get_text ();
			SQL += AUX +", cod_func=";
			AUX.clear();
			AUX = Cod_Digitador->get_text ();
			SQL += AUX + ",data_cancel='";
			SQL.append(hoje());
			SQL += "' where e_s=1 and data='";
			SQL += this->data_recibo + "' and rec=";
			SQL += this->numero_recibo +";";
			//cout << SQL << endl;
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			this->conexao->executar(sql);
			if (this->conexao->query_result == 3)
				{
				cout << this->conexao->mensagem << endl;
				}
			else
				{
				this->Rec_Status->set_markup("<span foreground='red' size='large' font_weight='bold'>CANCELADO</span>");
				this->Rec_GERAR->set_sensitive (false);
				this->Rec_CancelServ->set_sensitive (false);
				}
			dados->hide();
			break;
			}
		default:
			{
			dados->hide();
			break;
			}
		}
	}

/**
 * \param j Janela 
 * \param e Entry de entrada
 * \param r Label de Resposta
 * \param n 
 * \param tipo
 */
void RECIBO::checagem_cancelamento(Gtk::Window *j, Gtk::Entry *e, Gtk::Label *r, Gtk::Widget *n, int tipo)
	{
	string SQL, AUX;
	char *sql, *aux;
	vector<string> linha;

	AUX.clear();
	AUX = e->get_text ();
	switch(tipo)
		{
		case 1:
			{
			SQL.clear();
			SQL = "select * from cadastro.motivo where cod_mot="+AUX;
			break;
			}
		case 2:
			{
			SQL.clear();
			SQL = "select cod_fun, u_login from cadastro.funcionario where cod_fun="+AUX;
			break;
			}
		}
	//cout << SQL << endl;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		conexao->resultado();
		linha = conexao->resultados.at(0);
		AUX.clear();
		AUX = linha.at(1);
		r->set_label(Glib::ustring(AUX));
		j->set_focus(*n);
		}
	}

/**
 * Método utilizado para carregar dados de saídas
 */
void RECIBO::carregar_saida()
	{
	string SQL, AUX;
	char *aux, *sql;
	float valor;
	int it;
	vector<string> linha;

	SQL.clear();
	SQL = "select count(*) from caixa.lancamentos where e_s=2";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		this->saida_total = -1;
		}
	else
		{
		conexao->resultado();
		linha = conexao->resultados.at(0);
		this->saida_total = atoi(linha.at(0).c_str());
		}
	if (this->saida_total != -1)
		{
		aux = new char[32];
		sprintf(aux,"%d",this->saida_pagina);
		SQL.clear();
		SQL = "select lancamentos.rec, lancamentos.data, clientes.cod_cli, clientes.nome, servicos.codigo, servicos.descricao, saida.historico_complementar, saida.valor, servicos.cod_serv, lancamentos.status ";
		SQL += "from caixa.lancamentos inner join cadastro.clientes on lancamentos.cod_cli=clientes.cod_cli inner join caixa.saida on lancamentos.data=saida.data and lancamentos.rec=saida.rec inner join cadastro.servicos on saida.cod_serv=servicos.cod_serv where lancamentos.e_s=2 order by lancamentos.data desc, lancamentos.rec desc limit 1 offset ";
		SQL.append(aux);
		delete aux;
		sql = new char[SQL.length()+1];
		strcpy(sql,SQL.c_str());
		this->conexao->executar(sql);
		delete sql;
		if (this->conexao->query_result == 3)
			{
			cout << this->conexao->mensagem << endl;
			this->Rec_SaidaTE->set_text("ERRO");
			}
		else
			{
			conexao->resultado();
			linha = conexao->resultados.at(0);
			this->saida_numero.clear();
			saida_numero = linha.at(0);
			this->saida_data.clear();
			saida_data = linha.at(1);
			AUX.clear();
			aux = new char[20];
			strcpy(aux,this->saida_data.c_str());
			AUX = data_formatada(aux,2);
			delete aux;
			AUX += " "+this->saida_numero;
			this->Rec_SaidaTE->set_text(AUX);
			AUX.clear();
			AUX = linha.at(2);
			this->Rec_CliCod->set_text(AUX);
			AUX.clear();
			AUX = linha.at(3);
			this->Rec_Cliente->set_text(AUX);
			AUX.clear();
			AUX = linha.at(4);
			this->Rec_SerCod->set_text(AUX);
			AUX.clear();
			AUX = linha.at(5);
			this->Rec_Servico->set_text(AUX);
			AUX.clear();
			AUX = linha.at(6);
			this->RecSer_Hist->set_text(AUX);
			AUX.clear();
			AUX = linha.at(7);
			it = AUX.find(".");
			if (it!=string::npos)
				{
				AUX.replace(it,1,",");
				}
			valor = strtod(AUX.c_str(),NULL);
			aux = new char[32];
			sprintf(aux,"%.02f",valor);
			this->Rec_Total->set_text (casa_milhar(aux,0));
			delete aux;
			this->cod_servico = atoi(linha.at(8).c_str());
			AUX.clear();
			AUX = linha.at(9);
			if (AUX.compare ("t") == 0)
				{
				this->Rec_SaidaStatus->set_text("");
				this->Rec_SaidaTB[1]->set_sensitive (true);
				if (this->caixa)
					{
					this->Rec_SaidaTB[7]->set_sensitive (true);
					}
				}
			else
				{
				this->Rec_SaidaStatus->set_markup("<span foreground='red' size='large' font_weight='bold'>CANCELADO</span>");
				this->Rec_SaidaTB[1]->set_sensitive (false);
				this->Rec_SaidaTB[7]->set_sensitive (false);
				}
			}
		}
	}

/**
 * Método de Navegação sobre os registros de saída.
 * \param direcao
 */
void RECIBO::saida_navegar(int direcao)
	{
	switch(direcao)
		{
		case 1:
			{
			this->saida_pagina = 0;
			break;
			}
		case 2:
			{
			if (this->saida_pagina > 0)
				{
				this->saida_pagina--;
				}
			break;
			}
		case 3:
			{
			if (this->saida_pagina < this->saida_total-1)
				{
				this->saida_pagina++;
				}
			break;
			}
		case 4:
			{
			this->saida_pagina = this->saida_total-1;
			break;
			}
		}
	this->carregar_saida ();
	}

/**
 * \param acao
 */
void RECIBO::saida_acao(int acao)
	{
	int i, confirmar;
	Gtk::Label *Texto;
	Gtk::Entry *Senha;
	Gtk::HBox *BOX;
	string SQL, SENHA;
	char *sql;
	
	switch(acao)
		{
		case 0:
			{
			this->Rec_SaidaTB[6]->set_sensitive (false);
			this->Rec_SaidaTB[7]->set_sensitive (true);
			for (i=0; i < 6; i++)
				{
				this->Rec_SaidaTB[i]->set_sensitive (true);
				}
			this->Rec_CliCod->set_editable (false);
			this->Rec_Cliente->set_editable (false);
			this->Rec_SerCod->set_editable (false);
			this->Rec_Servico->set_editable (false);
			this->RecSer_Hist->set_editable (false);
			this->Rec_Total->set_editable (false);
			this->Rec_GERAR->set_sensitive (false);
			this->Rec_SALVAR->set_sensitive (false);
			this->saida_pagina = 0;
			this->carregar_saida();
			break;
			}
		case 1:
			{
			this->Rec_SaidaTB[6]->set_sensitive (true);
			this->Rec_SaidaTB[7]->set_sensitive (false);
			for (i=0; i < 6; i++)
				{
				this->Rec_SaidaTB[i]->set_sensitive (false);
				}
			this->Rec_CliCod->set_editable (true);
			this->Rec_Cliente->set_editable (true);
			this->Rec_SerCod->set_editable (true);
			this->Rec_Servico->set_editable (true);
			this->RecSer_Hist->set_editable (true);
			this->Rec_Total->set_editable (true);
			this->Rec_GERAR->set_sensitive (true);
			this->Rec_SaidaTE->set_text ("");
			this->Rec_CliCod->set_text ("");
			this->Rec_Cliente->set_text ("");
			this->Rec_SerCod->set_text ("");
			this->Rec_Servico->set_text ("");
			this->RecSer_Hist->set_text ("");
			this->Rec_Total->set_text ("");
			this->Recibo->set_focus (*this->Rec_CliCod);
			break;
			}
		case 2:
			{
			this->Rec_SaidaTB[6]->set_sensitive (true);
			this->Rec_SaidaTB[7]->set_sensitive (false);
			for (i=0; i < 6; i++)
				{
				this->Rec_SaidaTB[i]->set_sensitive (false);
				}
			this->Rec_CliCod->set_editable (true);
			this->Rec_Cliente->set_editable (true);
			this->Rec_SerCod->set_editable (true);
			this->Rec_Servico->set_editable (true);
			this->RecSer_Hist->set_editable (true);
			this->Rec_Total->set_editable (true);
			this->Rec_SALVAR->set_sensitive (true);
			this->Recibo->set_focus (*this->Rec_CliCod);
			break;
			}
		case 3:
			{
			Gtk::Dialog confirma(Glib::ustring("Confirmação"),*this->Recibo,false);
			confirma.set_size_request (200,70);
			confirma.add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
			confirma.add_button(Gtk::Stock::CANCEL,Gtk::RESPONSE_CANCEL);
			Texto =  new Gtk::Label("Senha: ");
			Senha = new Gtk::Entry();
			BOX = new Gtk::HBox(false,0);
			Senha->set_visibility (false);
			Senha->set_invisible_char ('*');
			Senha->signal_activate ().connect (sigc::bind(sigc::mem_fun(*this,&RECIBO::tabulacao),&confirma,confirma.get_widget_for_response (Gtk::RESPONSE_OK)));
			BOX->pack_start(*Texto,false,false,0);
			BOX->pack_start(*Senha,true,true,0);
			confirma.get_vbox ()->pack_start(*BOX,false,false,0);
			confirma.set_focus (*Senha);
			confirma.show_all();
			confirmar = confirma.run();
			switch(confirmar)
				{
				case Gtk::RESPONSE_OK:
					{
					SENHA.clear();
					SENHA = "302010";
					if (SENHA.compare(Senha->get_text ()) == 0)
						{
						SQL = "update caixa.lancamentos set status=false where e_s=2 and rec="+this->saida_numero+" and data='"+this->saida_data+"'";
						sql = new char[SQL.length()+1];
						strcpy(sql,SQL.c_str());
						this->conexao->executar(sql);
						if (this->conexao->query_result == 3)
							{
							cout << this->conexao->mensagem << endl;
							}
						}
					break;
					}
				case Gtk::RESPONSE_CANCEL:
					{
					break;
					}
				}
			this->carregar_saida();
			break;
			}
		}
	}

/**
 *
 */
void RECIBO::voltar_credito ()
	{
	string SQL;
	char *sql;
	SQL.clear();
	SQL = "update caixa.lancamentos set tipo='C', data_qt=null where e_s=1 and rec="+this->numero_recibo+" and data='"+this->data_recibo+"'";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	this->Rec_BDebCred->set_sensitive (false);
	this->carregar_dados (4,0);
	}

/**
 * \param servico
 */
int RECIBO::contar_selos (int servico)
	{
	string SQL, AUX;
	char *sql, *aux;
	BANCOMY *protesto;
	BANCOMY *notas;
	BANCOMY *selos;
	int retorno;

	retorno = 0;
	SQL.clear();
	//cout << servico << endl;
	switch(servico)
		{
		case 1:
			{
			//reconhecimentos
			notas = new BANCOMY(CONF_FILE2);
			SQL = "select selo_numero from emitidas where data_impr='"+this->data_sel+"' and tipo like 'Reconhe%' and usu_impr='"+this->n_func+"'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			notas->executar(sql,2);
			delete sql;
			if (notas->query_result == 3)
				{
				cout << notas->mensagem << endl;
				}
			else
				{
				retorno = notas->registros;
				}
			delete notas;
			break;
			}
		case 2:
			{
			notas = new BANCOMY(CONF_FILE2);
			SQL = "select selo_numero from emitidas where data_impr='"+this->data_sel+"' and tipo like 'Autenticacao' and usu_impr='"+this->n_func+"'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			notas->executar(sql,2);
			delete sql;
			if (notas->query_result == 3)
				{
				cout << notas->mensagem << endl;
				}
			else
				{
				retorno = notas->registros;
				}
			delete notas;
			break;
			}
		case 3:
			{
			notas = new BANCOMY(CONF_FILE2);
			SQL = "select ficha from firmas where data_inclu='"+this->data_sel+"' and digitador='"+this->n_login+"'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			notas->executar(sql,2);
			delete sql;
			if (notas->query_result == 3)
				{
				cout << notas->mensagem << endl;
				}
			else
				{
				retorno = notas->registros;
				}
			delete notas;
			break;
			}
		case 6:
			{
			protesto = new BANCOMY(CONF_FILE1);
			SQL = "select numero from pt_pedid where data='"+this->data_sel+"' and usuario='"+this->n_login+"' and (tipo_cert like 'Certid%' or tipo_cert like 'Breve%')";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			protesto->executar(sql,2);
			delete sql;
			if (protesto->query_result == 3)
				{
				cout << protesto->mensagem << endl;
				}
			else
				{
				retorno = protesto->registros;
				}
			delete protesto;
			break;
			}
		case 7:
			{
			protesto = new BANCOMY(CONF_FILE1);
			SQL = "select numero from pt_pedid where data='"+this->data_sel+"' and usuario='"+this->n_login+"' and tipo_cert like 'Cancelamento%'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			protesto->executar(sql,2);
			delete sql;
			if (protesto->query_result == 3)
				{
				cout << protesto->mensagem << endl;
				}
			else
				{
				retorno = protesto->registros;
				}
			delete protesto;
			break;
			}
		case 10:
			{
			protesto = new BANCOMY(CONF_FILE1);
			SQL = "select protocolo from pt_mov where data_re='"+this->data_sel+"' and identific1 like '"+this->n_login+"%'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			protesto->executar(sql,2);
			delete sql;
			if (protesto->query_result == 3)
				{
				cout << protesto->mensagem << endl;
				}
			else
				{
				retorno = protesto->registros;
				}
			delete protesto;
			break;
			}
		/*case 14:
			{
			selos = new BANCOMY(CONF_FILE3);
			SQL = "select row_id from selosutils2 where data_ato='"+this->data_sel+"' and id_ato like '"+this->n_login+"%'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			selos->executar(sql,2);
			delete sql;
			if (selos->query_result == 3)
				{
				cout << selos->mensagem << endl;
				}
			else
				{
				retorno = selos->registros;
				}
			delete selos;
			break;
			}*/
		case 19:
			{
			notas = new BANCOMY(CONF_FILE2);
			SQL = "select nr_protoc from certidao where data='"+this->data_sel+"' and identifica='"+this->n_login+"'";
			sql = new char[SQL.length()+1];
			strcpy(sql,SQL.c_str());
			//cout << sql << endl;
			notas->executar(sql,2);
			delete sql;
			if (notas->query_result == 3)
				{
				cout << notas->mensagem << endl;
				}
			else
				{
				retorno = notas->registros;
				}
			delete notas;
			break;
			}
		}
	return (retorno);
	}

/**
 *
 */
void RECIBO::consultar_cliente()
	{
	int i;
	Gtk::VBox *VBOX;
	Gtk::HBox *HBOX;
	Gtk::Label *LABEL;
	Gtk::Entry *ENTRY;
	
	this->Consulta_Cli = new Gtk::Window();
	this->Consulta_Cli->set_title (Glib::ustring("Consulta de Clientes"));
	this->Consulta_Cli->set_size_request (300,300);
	this->Consulta_Cli->set_icon(this->ponteiro_icon);
	this->Consulta_Cli->set_type_hint(Gdk::WINDOW_TYPE_HINT_DIALOG);
	this->Consulta_Cli->set_position(Gtk::WIN_POS_CENTER);
	VBOX = new Gtk::VBox(false,0);
	HBOX = new Gtk::HBox(false,0);
	LABEL = new Gtk::Label(Glib::ustring("Cliente: "));
	HBOX->pack_start(*LABEL,false,false,0);
	ENTRY = new Gtk::Entry();
	ENTRY->signal_changed().connect(sigc::bind(sigc::mem_fun(*this,&RECIBO::carrega_cliente),ENTRY));
	HBOX->pack_start(*ENTRY,true,true,0);
	VBOX->pack_start(*HBOX,false,false,0);
	HBOX = new Gtk::HBox(false,0);
	this->CS_Cliente = new Gtk::ScrolledWindow();
	this->CS_Cliente->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	this->CT_Cliente = new Gtk::TreeView();
	this->CS_Cliente->add(*this->CT_Cliente);
	arvore_refc = Gtk::ListStore::create(arvore_cli);
	this->CT_Cliente->set_model(arvore_refc);
	this->CT_Cliente->remove_all_columns();
	this->CT_Cliente->append_column(Glib::ustring("Código"),arvore_cli.campo[0]);
	this->CT_Cliente->append_column(Glib::ustring("Nome"),arvore_cli.campo[1]);
	for(i=0; i < 2; i++)
		{
		Gtk::TreeView::Column* coluna_temp = this->CT_Cliente->get_column(i);
		coluna_temp->set_reorderable();	
		}
	this->CT_Cliente->signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::cli_sel));
	HBOX->pack_start(*this->CS_Cliente);
	VBOX->pack_start(*HBOX,true,true,0);
	this->Consulta_Cli->add(*VBOX);
	this->Consulta_Cli->show_all ();
	Gtk::Main::run(*this->Consulta_Cli);
	}

/**
 * \param e Entry
 */
void RECIBO::carrega_cliente(Gtk::Entry *e)
	{
	string AUX, SQL;
	char *sql;
	int i, total;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	AUX.clear();
	AUX = e->get_text ();
	AUX = ParaMaiusculos(AUX);
	e->set_text (AUX);
	SQL.clear();
	SQL = "select cod_cli, nome from cadastro.clientes where credito and nome like '"+AUX+"%' order by nome";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	this->conexao->executar(sql);
	delete sql;
	arvore_refc = Gtk::ListStore::create(arvore_cli);
	this->CT_Cliente->set_model(arvore_refc);
	if (this->conexao->query_result == 3)
		{
		celula =  *(arvore_refc->append());
		celula[arvore_cli.cod_cli] = 0;
		celula[arvore_cli.campo[0]]= "Erro de SQL";
		celula[arvore_cli.campo[1]]= this->conexao->mensagem;
		}
	else
		{
		total = this->conexao->registros;
		conexao->resultado();
		for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
			{
			linha = *ir;
			celula =  *(arvore_refc->append());
			celula[arvore_cli.cod_cli] = atoi(linha.at(0).c_str());
			celula[arvore_cli.campo[0]]= linha.at(0);
			celula[arvore_cli.campo[1]]= linha.at(1);
			}
		}
	this->CT_Cliente->remove_all_columns();
	this->CT_Cliente->append_column(Glib::ustring("Código"),arvore_cli.campo[0]);
	this->CT_Cliente->append_column(Glib::ustring("Nome"),arvore_cli.campo[1]);
	for(i=0; i < 2; i++)
		{
		Gtk::TreeView::Column* coluna_temp = this->CT_Cliente->get_column(i);
		coluna_temp->set_reorderable();	
		}
	}

/**
 * \param path caminho do tipo Gtk::TreeModel::Path.
 * \param column coluna do tipo Gtk::TreeView::Column.
 */
void RECIBO::cli_sel(const Gtk::TreeModel::Path& path, Gtk::TreeViewColumn* column)
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	int i;

	contador = arvore_refc->get_iter(path);
	if(contador)
		{
		registro=*contador;
		if(registro)
			{
			this->Rec_CliCod->set_text(registro[arvore_cli.campo[0]]);
			}
		}
	this->carregar_dados(1,1);
	this->Consulta_Cli->hide();
	}

/**
 *
 */

float RECIBO::arredondar (float valor)
	{
	float vlr, vlr2, vlr3;
	int digito;

	vlr3 = (int) valor;
	vlr = valor * 1000;
	vlr2 = (int) (valor * 100) * 10;

	//cout << valor << " - " << vlr << " - " << vlr2 << " - " << vlr3 << endl;
	if ( (vlr - vlr2) > 5)
		{
		vlr2+=10;
		}
	valor = vlr2/1000;
	//cout << valor << endl;
	return valor;
	}

/**
 * Últimos 20 recibos emitidos
 */
void RECIBO::ultimos_recibos ()
	{
	string SQL;
	char *sql;

	this->t_ultimos = true; 
	SQL.clear();
	SQL = "prepare ultimos as select lancamentos.data, lancamentos.rec, clientes.nome, lancamentos.total, lancamentos.e_s, lancamentos.tipo, funcionario.u_login ";
	SQL += "from caixa.lancamentos inner join cadastro.clientes on lancamentos.cod_cli=clientes.cod_cli inner join cadastro.funcionario on lancamentos.cod_fun=funcionario.cod_fun ";
	SQL += "where lancamentos.status order by lancamentos.data desc, lancamentos.rec desc limit 20 offset 0;";
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	this->Ultimos = new Gtk::Window();
	this->Ultimos->set_icon (ponteiro_icon);
	this->Ultimos->set_position (Gtk::WIN_POS_CENTER);
	this->Ultimos->set_title(Glib::ustring("Recibo: Últimos emitidos"));
	this->Ultimos->set_size_request (500,550);
	//this->Ultimos->signal_show ().connect (sigc::mem_fun(*this,&RECIBO::carregar_ultimos));
	this->Ultimos->signal_hide ().connect (sigc::mem_fun(*this,&RECIBO::sairU));
	this->Rec_UScroll = new Gtk::ScrolledWindow();
	this->Rec_UScroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
	this->Rec_UDados = new Gtk::TreeView();
	this->Rec_UScroll->add(*this->Rec_UDados);
	this->dados_ultimos = Gtk::ListStore::create(this->dados_arv);
	this->Rec_UDados->set_model(this->dados_ultimos);
	this->Rec_UDados->remove_all_columns();
	this->Rec_UDados->append_column(Glib::ustring("Recibo"), arvore_reg.campo[0]);
	this->Rec_UDados->append_column(Glib::ustring("Cliente"), arvore_reg.campo[1]);
	this->Rec_UDados->append_column_numeric(Glib::ustring("Valor R$"), arvore_reg.campo_num,"%.2f");
	this->Rec_UDados->append_column (Glib::ustring("Tipo"), arvore_reg.campo[2]);
	this->Rec_UDados->append_column (Glib::ustring("Funcionário"), arvore_reg.campo[3]);
	for(int i=0; i < 5; i++)
		{
		Gtk::TreeView::Column* coluna_temp = this->Rec_UDados->get_column(i);
		coluna_temp->set_reorderable();	
		}
	this->Rec_UDados->signal_row_activated().connect(sigc::mem_fun(*this,&RECIBO::selecionadoU));
	this->Ultimos->add(*this->Rec_UScroll);
	Glib::signal_timeout().connect(sigc::mem_fun(*this,&RECIBO::carregar_ultimos), 2000);
	this->Ultimos->show_all ();
	Gtk::Main::run(*this->Ultimos);
	}

/**
 * Carregar últimos 20 recibos.
 */
bool RECIBO::carregar_ultimos ()
	{
	char *sql, *aux_n;
	string SQL, aux;
	int registro, colunas, i,j,x, it;
	vector<vector<string> >::iterator ir;
	vector<string> linha;

	SQL.clear();
	SQL = "execute ultimos;";
	delete aux_n;
	sql = new char[SQL.length()+1];
	strcpy(sql,SQL.c_str());
	//cout << sql << endl;
	this->conexao->executar(sql);
	delete sql;
	if (this->conexao->query_result == 3)
		{
		cout << this->conexao->mensagem << endl;
		}
	else
		{
		registro = this->conexao->registros;
		colunas = this->conexao->colunas;
		dados_ultimos = Gtk::ListStore::create(dados_arv);
		this->Rec_UDados->set_model(dados_ultimos);
		conexao->resultado();
		for (ir=conexao->resultados.begin(); ir < conexao->resultados.end(); ir++)
			{
			linha = *ir;
			celula = *(dados_ultimos->append());
			celula[dados_arv.data] = linha.at(0);
			celula[dados_arv.n_recibo] = atoi(linha.at(1).c_str());
			celula[dados_arv.tipo] = atoi(linha.at(4).c_str());
			celula[dados_arv.campo[0]]= linha.at(1);
			celula[dados_arv.campo[1]]= linha.at(2);
			aux.clear();
			aux = linha.at(3);
			it = aux.find(".");
			if (it!=string::npos)
	  			{
				aux.replace(it,1,",");
				}
			celula[dados_arv.campo_num]= atof(aux.c_str());
			if (celula[dados_arv.tipo] == 2)
				{
				celula[dados_arv.campo[2]] = "S";
				}
			else
				{
				celula[dados_arv.campo[2]] = linha.at(5);
				}
			celula[dados_arv.campo[3]] = linha.at(6);
			}
		this->Rec_UDados->remove_all_columns();
		this->Rec_UDados->append_column(Glib::ustring("Recibo"), arvore_reg.campo[0]);
		this->Rec_UDados->append_column(Glib::ustring("Cliente"), arvore_reg.campo[1]);
		this->Rec_UDados->append_column_numeric(Glib::ustring("Valor R$"), arvore_reg.campo_num,"%.2f");
		this->Rec_UDados->append_column (Glib::ustring("Tipo"), arvore_reg.campo[2]);
		this->Rec_UDados->append_column (Glib::ustring("Funcionário"), arvore_reg.campo[3]);
		for(i=0; i < 5; i++)
			{
			Gtk::TreeView::Column* coluna_temp = this->Rec_UDados->get_column(i);
			coluna_temp->set_reorderable();	
			}
		}
	//cout << "EXECUTOU" << endl;
	return this->t_ultimos;
	}

/**
 * \param caminho passagem por referência da linha do TreeViewColumn que foi clicado
 * \param coluna Coluna da TreeViewColumn.
 */
void RECIBO::selecionadoU(const Gtk::TreeModel::Path& caminho, Gtk::TreeViewColumn* coluna)
	{
	Gtk::TreeModel::iterator contador;
	Gtk::TreeModel::Row registro;
	Glib::ustring AUX;
	IMPRIMIR *reimprimir;

	contador =  this->dados_ultimos->get_iter(caminho);
	if (contador)
		{
		registro = *contador;
		if (registro)
			{
			//this->BT_Reimprimir.set_sensitive(true);
			if ((this->n_acesso == 0)||(this->caixa))
				{
				reimprimir = new IMPRIMIR(this->conexao,registro[dados_arv.tipo],registro[dados_arv.data],registro[dados_arv.n_recibo]);
				}
			}
		}
	}

/**
 *
 */
void RECIBO::sairU()
	{
	this->Ultimos->hide();
	this->t_ultimos = false;
	}

/**
 * Considerando a data do sistema será carregado as informações sobre os títulos
 * pagos.
 */
void RECIBO::resumo_titulos ()
	{
	string SQL, AUX;
	char *aux, *sql;
	int it;
	BANCOMY *resumo;

	resumo = new BANCOMY(CONF_FILE1);

	delete resumo;
	}